hermez-node/eth/auction_test.go
eth/auction_test.goRaw
1package eth
2
3import (
4 "io/ioutil"
5 "math/big"
6 "os"
7 "testing"
8
9 "github.com/ethereum/go-ethereum/accounts/keystore"
10 "github.com/ethereum/go-ethereum/common"
11 "github.com/ethereum/go-ethereum/crypto"
12 "github.com/ethereum/go-ethereum/ethclient"
13 "github.com/stretchr/testify/assert"
14 "github.com/stretchr/testify/require"
15)
16
17const slotDeadlineConst = uint8(20)
18const openAuctionSlotsConst = uint16(4320)
19const closedAuctionSlotsConst = uint16(2)
20const outbiddingConst = uint16(1000)
21const currentSlotConst = 0
22
23var allocationRatioConst [3]uint16 = [3]uint16{4000, 4000, 2000}
24
25var auctionClient *AuctionClient
26
27/*var donationAddressStr = os.Getenv("DONATION_ADDRESS")
28var bootCoordinatorStr = os.Getenv("BOOT_COORDINATOR_ADDRESS")
29var ehtClientDialURL = os.Getenv("ETHCLIENT_DIAL_URL")
30var auctionAddressStr = os.Getenv("AUCTION_ADDRESS")*/
31var integration = os.Getenv("INTEGRATION")
32
33var donationAddressStr = "0x6c365935CA8710200C7595F0a72EB6023A7706Cd"
34var bootCoordinatorStr = "0xc783df8a850f42e7f7e57013759c285caa701eb6"
35var DONATION = common.HexToAddress(donationAddressStr)
36var BOOTCOORDINATOR = common.HexToAddress(bootCoordinatorStr)
37
38var ehtClientDialURL = "http://localhost:8545"
39var auctionAddressStr = "0x3619DbE27d7c1e7E91aA738697Ae7Bc5FC3eACA5"
40
41// var ownerAddressStr = "0xc783df8a850f42e7F7e57013759C285caa701eB6"
42var governanceAddressStr = "0xead9c93b79ae7c1591b1fb5323bd777e86e150d4"
43var governancePrivateKey = "d49743deccbccc5dc7baa8e69e5be03298da8688a15dd202e20f15d5e0e9a9fb"
44var minBidStr = "10000000000000000000"
45var URL = "http://localhost:3000"
46var newURL = "http://localhost:3002"
47var BLOCKSPERSLOT = uint8(40)
48var TOKENHEZ = common.HexToAddress("0xf4e77E5Da47AC3125140c470c71cBca77B5c638c")
49var HERMEZROLLUP = common.HexToAddress("0xc4905364b78a742ccce7B890A89514061E47068D")
50
51var password = "pass"
52
53func TestNewAction(t *testing.T) {
54 key, err := crypto.HexToECDSA(governancePrivateKey)
55 require.Nil(t, err)
56 dir, err := ioutil.TempDir("", "tmpks")
57 require.Nil(t, err)
58 ks := keystore.NewKeyStore(dir, keystore.StandardScryptN, keystore.StandardScryptP)
59 account, err := ks.ImportECDSA(key, password)
60 require.Nil(t, err)
61 err = ks.Unlock(account, password)
62 require.Nil(t, err)
63 // Init eth client
64 ethClient, err := ethclient.Dial(ehtClientDialURL)
65 require.Nil(t, err)
66 ethereumClient := NewEthereumClient(ethClient, &account, ks, nil)
67 auctionAddress := common.HexToAddress(auctionAddressStr)
68 if integration != "" {
69 auctionClient = NewAuctionClient(ethereumClient, auctionAddress)
70 }
71}
72
73func TestAuctionGetCurrentSlotNumber(t *testing.T) {
74 if auctionClient != nil {
75 currentSlot, err := auctionClient.AuctionGetCurrentSlotNumber()
76 require.Nil(t, err)
77 currentSlotInt := int(currentSlot)
78 assert.Equal(t, currentSlotConst, currentSlotInt)
79 }
80}
81
82func TestAuctionConstants(t *testing.T) {
83 INITMINBID := new(big.Int)
84 INITMINBID.SetString(minBidStr, 10)
85 if auctionClient != nil {
86 auctionConstants, err := auctionClient.AuctionConstants()
87 require.Nil(t, err)
88 assert.Equal(t, auctionConstants.BlocksPerSlot, BLOCKSPERSLOT)
89 // assert.Equal(t, auctionConstants.GenesisBlockNum, GENESISBLOCKNUM)
90 assert.Equal(t, auctionConstants.HermezRollup, HERMEZROLLUP)
91 assert.Equal(t, auctionConstants.InitialMinimalBidding, INITMINBID)
92 assert.Equal(t, auctionConstants.TokenHEZ, TOKENHEZ)
93 }
94}
95
96func TestAuctionVariables(t *testing.T) {
97 INITMINBID := new(big.Int)
98 INITMINBID.SetString(minBidStr, 10)
99 defaultSlotSetBid := [6]*big.Int{INITMINBID, INITMINBID, INITMINBID, INITMINBID, INITMINBID, INITMINBID}
100 if auctionClient != nil {
101 auctionVariables, err := auctionClient.AuctionVariables()
102 require.Nil(t, err)
103 assert.Equal(t, auctionVariables.AllocationRatio, allocationRatioConst)
104 assert.Equal(t, auctionVariables.BootCoordinator, &BOOTCOORDINATOR)
105 assert.Equal(t, auctionVariables.ClosedAuctionSlots, closedAuctionSlotsConst)
106 assert.Equal(t, auctionVariables.DefaultSlotSetBid, defaultSlotSetBid)
107 assert.Equal(t, auctionVariables.DonationAddress, &DONATION)
108 assert.Equal(t, auctionVariables.OpenAuctionSlots, openAuctionSlotsConst)
109 assert.Equal(t, auctionVariables.Outbidding, outbiddingConst)
110 assert.Equal(t, auctionVariables.SlotDeadline, slotDeadlineConst)
111 }
112}
113
114func TestAuctionGetSlotDeadline(t *testing.T) {
115 if auctionClient != nil {
116 slotDeadline, err := auctionClient.AuctionGetSlotDeadline()
117 require.Nil(t, err)
118 assert.Equal(t, slotDeadlineConst, slotDeadline)
119 }
120}
121
122func TestAuctionSetSlotDeadline(t *testing.T) {
123 newSlotDeadline := uint8(25)
124 if auctionClient != nil {
125 _, err := auctionClient.AuctionSetSlotDeadline(newSlotDeadline)
126 require.Nil(t, err)
127 slotDeadline, err := auctionClient.AuctionGetSlotDeadline()
128 require.Nil(t, err)
129 assert.Equal(t, newSlotDeadline, slotDeadline)
130 _, err = auctionClient.AuctionSetSlotDeadline(slotDeadlineConst)
131 require.Nil(t, err)
132 }
133}
134
135func TestAuctionGetOpenAuctionSlots(t *testing.T) {
136 if auctionClient != nil {
137 openAuctionSlots, err := auctionClient.AuctionGetOpenAuctionSlots()
138 require.Nil(t, err)
139 assert.Equal(t, openAuctionSlotsConst, openAuctionSlots)
140 }
141}
142
143func TestAuctionSetOpenAuctionSlots(t *testing.T) {
144 newOpenAuctionSlots := uint16(4500)
145 if auctionClient != nil {
146 _, err := auctionClient.AuctionSetOpenAuctionSlots(newOpenAuctionSlots)
147 require.Nil(t, err)
148 openAuctionSlots, err := auctionClient.AuctionGetOpenAuctionSlots()
149 require.Nil(t, err)
150 assert.Equal(t, newOpenAuctionSlots, openAuctionSlots)
151 _, err = auctionClient.AuctionSetOpenAuctionSlots(openAuctionSlotsConst)
152 require.Nil(t, err)
153 }
154}
155
156func TestAuctionGetClosedAuctionSlots(t *testing.T) {
157 if auctionClient != nil {
158 closedAuctionSlots, err := auctionClient.AuctionGetClosedAuctionSlots()
159 require.Nil(t, err)
160 assert.Equal(t, closedAuctionSlotsConst, closedAuctionSlots)
161 }
162}
163
164func TestAuctionSetClosedAuctionSlots(t *testing.T) {
165 newClosedAuctionSlots := uint16(5)
166 if auctionClient != nil {
167 _, err := auctionClient.AuctionSetClosedAuctionSlots(newClosedAuctionSlots)
168 require.Nil(t, err)
169 closedAuctionSlots, err := auctionClient.AuctionGetClosedAuctionSlots()
170 require.Nil(t, err)
171 assert.Equal(t, newClosedAuctionSlots, closedAuctionSlots)
172 _, err = auctionClient.AuctionSetClosedAuctionSlots(closedAuctionSlotsConst)
173 require.Nil(t, err)
174 }
175}
176
177func TestAuctionGetOutbidding(t *testing.T) {
178 if auctionClient != nil {
179 outbidding, err := auctionClient.AuctionGetOutbidding()
180 require.Nil(t, err)
181 assert.Equal(t, outbiddingConst, outbidding)
182 }
183}
184
185func TestAuctionSetOutbidding(t *testing.T) {
186 newOutbidding := uint16(0xb)
187 if auctionClient != nil {
188 _, err := auctionClient.AuctionSetOutbidding(newOutbidding)
189 require.Nil(t, err)
190 outbidding, err := auctionClient.AuctionGetOutbidding()
191 require.Nil(t, err)
192 assert.Equal(t, newOutbidding, outbidding)
193 _, err = auctionClient.AuctionSetOutbidding(outbiddingConst)
194 require.Nil(t, err)
195 }
196}
197
198func TestAuctionGetAllocationRatio(t *testing.T) {
199 if auctionClient != nil {
200 allocationRatio, err := auctionClient.AuctionGetAllocationRatio()
201 require.Nil(t, err)
202 assert.Equal(t, allocationRatioConst, allocationRatio)
203 }
204}
205
206func TestAuctionSetAllocationRatio(t *testing.T) {
207 newAllocationRatio := [3]uint16{3000, 3000, 4000}
208 if auctionClient != nil {
209 _, err := auctionClient.AuctionSetAllocationRatio(newAllocationRatio)
210 require.Nil(t, err)
211 allocationRatio, err := auctionClient.AuctionGetAllocationRatio()
212 require.Nil(t, err)
213 assert.Equal(t, newAllocationRatio, allocationRatio)
214 _, err = auctionClient.AuctionSetAllocationRatio(allocationRatioConst)
215 require.Nil(t, err)
216 }
217}
218
219func TestAuctionGetDonationAddress(t *testing.T) {
220 if auctionClient != nil {
221 donationAddress, err := auctionClient.AuctionGetDonationAddress()
222 require.Nil(t, err)
223 donationAddressConst := common.HexToAddress(donationAddressStr)
224 assert.Equal(t, &donationAddressConst, donationAddress)
225 }
226}
227
228func TestAuctionGetBootCoordinator(t *testing.T) {
229 if auctionClient != nil {
230 bootCoordinator, err := auctionClient.AuctionGetBootCoordinator()
231 require.Nil(t, err)
232 bootCoordinatorConst := common.HexToAddress(bootCoordinatorStr)
233 assert.Equal(t, &bootCoordinatorConst, bootCoordinator)
234 }
235}
236
237func TestAuctionSetDonationAddress(t *testing.T) {
238 newDonationAddress := common.HexToAddress(governanceAddressStr)
239 if auctionClient != nil {
240 _, err := auctionClient.AuctionSetDonationAddress(newDonationAddress)
241 require.Nil(t, err)
242 donationAddress, err := auctionClient.AuctionGetDonationAddress()
243 require.Nil(t, err)
244 assert.Equal(t, &newDonationAddress, donationAddress)
245 donationAddressConst := common.HexToAddress(donationAddressStr)
246 _, err = auctionClient.AuctionSetDonationAddress(donationAddressConst)
247 require.Nil(t, err)
248 }
249}
250
251func TestAuctionSetBootCoordinator(t *testing.T) {
252 newBootCoordinator := common.HexToAddress(governanceAddressStr)
253 if auctionClient != nil {
254 _, err := auctionClient.AuctionSetBootCoordinator(newBootCoordinator)
255 require.Nil(t, err)
256 bootCoordinator, err := auctionClient.AuctionGetBootCoordinator()
257 require.Nil(t, err)
258 assert.Equal(t, &newBootCoordinator, bootCoordinator)
259 bootCoordinatorConst := common.HexToAddress(bootCoordinatorStr)
260 _, err = auctionClient.AuctionSetBootCoordinator(bootCoordinatorConst)
261 require.Nil(t, err)
262 }
263}
264
265func TestAuctionGetDefaultSlotSetBid(t *testing.T) {
266 slotSet := uint8(3)
267 if auctionClient != nil {
268 minBid, err := auctionClient.AuctionGetDefaultSlotSetBid(slotSet)
269 require.Nil(t, err)
270 assert.Equal(t, minBid.String(), minBidStr)
271 }
272}
273
274func TestAuctionChangeEpochMinBid(t *testing.T) {
275 slotSet := int64(3)
276 set := uint8(3)
277 newInitialMinBid := new(big.Int)
278 newInitialMinBid.SetString("20000000000000000000", 10)
279 if auctionClient != nil {
280 _, err := auctionClient.AuctionChangeDefaultSlotSetBid(slotSet, newInitialMinBid)
281 require.Nil(t, err)
282 minBid, err := auctionClient.AuctionGetDefaultSlotSetBid(set)
283 require.Nil(t, err)
284 assert.Equal(t, minBid, newInitialMinBid)
285 newMinBid := new(big.Int)
286 newMinBid.SetString("10000000000000000000", 10)
287 _, err = auctionClient.AuctionChangeDefaultSlotSetBid(slotSet, newMinBid)
288 require.Nil(t, err)
289 }
290}
291
292func TestAuctionIsRegisteredCoordinator(t *testing.T) {
293 forgerAddress := common.HexToAddress(governanceAddressStr)
294 if auctionClient != nil {
295 registered, err := auctionClient.AuctionIsRegisteredCoordinator(forgerAddress)
296 require.Nil(t, err)
297 assert.Equal(t, registered, false)
298 }
299}
300
301func TestAuctionRegisterCoordinator(t *testing.T) {
302 forgerAddress := common.HexToAddress(governanceAddressStr)
303 if auctionClient != nil {
304 _, err := auctionClient.AuctionRegisterCoordinator(forgerAddress, URL)
305 require.Nil(t, err)
306 }
307}
308
309func TestAuctionIsRegisteredCoordinatorTrue(t *testing.T) {
310 forgerAddress := common.HexToAddress(governanceAddressStr)
311 if auctionClient != nil {
312 registered, err := auctionClient.AuctionIsRegisteredCoordinator(forgerAddress)
313 require.Nil(t, err)
314 assert.Equal(t, registered, true)
315 }
316}
317
318func TestAuctionUpdateCoordinatorInfo(t *testing.T) {
319 forgerAddress := common.HexToAddress(governanceAddressStr)
320 if auctionClient != nil {
321 _, err := auctionClient.AuctionUpdateCoordinatorInfo(forgerAddress, forgerAddress, newURL)
322 require.Nil(t, err)
323 }
324}