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 auctionAddressStr = os.Getenv("AUCTION_ADDRESS")
30var tokenHezStr = os.Getenv("TOKEN_ADDRESS")
31var hermezStr = os.Getenv("HERMEZ_ADDRESS")
32var governanceAddressStr = os.Getenv("GOV_ADDRESS")
33var governancePrivateKey = os.Getenv("GOV_PK")
34var ehtClientDialURL = os.Getenv("ETHCLIENT_DIAL_URL")*/
35var integration = os.Getenv("INTEGRATION")
36
37var donationAddressStr = "0x6c365935CA8710200C7595F0a72EB6023A7706Cd"
38var bootCoordinatorStr = "0xc783df8a850f42e7f7e57013759c285caa701eb6"
39var auctionAddressStr = "0x3619DbE27d7c1e7E91aA738697Ae7Bc5FC3eACA5"
40var tokenHezStr = "0xf4e77E5Da47AC3125140c470c71cBca77B5c638c" //nolint:gosec
41var hermezStr = "0xc4905364b78a742ccce7B890A89514061E47068D"
42var governanceAddressStr = "0xead9c93b79ae7c1591b1fb5323bd777e86e150d4"
43var governancePrivateKey = "d49743deccbccc5dc7baa8e69e5be03298da8688a15dd202e20f15d5e0e9a9fb"
44var ehtClientDialURL = "http://localhost:8545"
45var DONATION = common.HexToAddress(donationAddressStr)
46var BOOTCOORDINATOR = common.HexToAddress(bootCoordinatorStr)
47var TOKENHEZ = common.HexToAddress(tokenHezStr)
48var HERMEZROLLUP = common.HexToAddress(hermezStr)
49
50var minBidStr = "10000000000000000000"
51var URL = "http://localhost:3000"
52var newURL = "http://localhost:3002"
53var BLOCKSPERSLOT = uint8(40)
54var password = "pass"
55
56func TestNewAction(t *testing.T) {
57 key, err := crypto.HexToECDSA(governancePrivateKey)
58 require.Nil(t, err)
59 dir, err := ioutil.TempDir("", "tmpks")
60 require.Nil(t, err)
61 ks := keystore.NewKeyStore(dir, keystore.StandardScryptN, keystore.StandardScryptP)
62 account, err := ks.ImportECDSA(key, password)
63 require.Nil(t, err)
64 err = ks.Unlock(account, password)
65 require.Nil(t, err)
66 // Init eth client
67 ethClient, err := ethclient.Dial(ehtClientDialURL)
68 require.Nil(t, err)
69 ethereumClient := NewEthereumClient(ethClient, &account, ks, nil)
70 auctionAddress := common.HexToAddress(auctionAddressStr)
71 if integration != "" {
72 auctionClient = NewAuctionClient(ethereumClient, auctionAddress)
73 }
74}
75
76func TestAuctionGetCurrentSlotNumber(t *testing.T) {
77 if auctionClient != nil {
78 currentSlot, err := auctionClient.AuctionGetCurrentSlotNumber()
79 require.Nil(t, err)
80 currentSlotInt := int(currentSlot)
81 assert.Equal(t, currentSlotConst, currentSlotInt)
82 }
83}
84
85func TestAuctionConstants(t *testing.T) {
86 INITMINBID := new(big.Int)
87 INITMINBID.SetString(minBidStr, 10)
88 if auctionClient != nil {
89 auctionConstants, err := auctionClient.AuctionConstants()
90 require.Nil(t, err)
91 assert.Equal(t, auctionConstants.BlocksPerSlot, BLOCKSPERSLOT)
92 // assert.Equal(t, auctionConstants.GenesisBlockNum, GENESISBLOCKNUM)
93 assert.Equal(t, auctionConstants.HermezRollup, HERMEZROLLUP)
94 assert.Equal(t, auctionConstants.InitialMinimalBidding, INITMINBID)
95 assert.Equal(t, auctionConstants.TokenHEZ, TOKENHEZ)
96 }
97}
98
99func TestAuctionVariables(t *testing.T) {
100 INITMINBID := new(big.Int)
101 INITMINBID.SetString(minBidStr, 10)
102 defaultSlotSetBid := [6]*big.Int{INITMINBID, INITMINBID, INITMINBID, INITMINBID, INITMINBID, INITMINBID}
103 if auctionClient != nil {
104 auctionVariables, err := auctionClient.AuctionVariables()
105 require.Nil(t, err)
106 assert.Equal(t, auctionVariables.AllocationRatio, allocationRatioConst)
107 assert.Equal(t, auctionVariables.BootCoordinator, BOOTCOORDINATOR)
108 assert.Equal(t, auctionVariables.ClosedAuctionSlots, closedAuctionSlotsConst)
109 assert.Equal(t, auctionVariables.DefaultSlotSetBid, defaultSlotSetBid)
110 assert.Equal(t, auctionVariables.DonationAddress, DONATION)
111 assert.Equal(t, auctionVariables.OpenAuctionSlots, openAuctionSlotsConst)
112 assert.Equal(t, auctionVariables.Outbidding, outbiddingConst)
113 assert.Equal(t, auctionVariables.SlotDeadline, slotDeadlineConst)
114 }
115}
116
117func TestAuctionGetSlotDeadline(t *testing.T) {
118 if auctionClient != nil {
119 slotDeadline, err := auctionClient.AuctionGetSlotDeadline()
120 require.Nil(t, err)
121 assert.Equal(t, slotDeadlineConst, slotDeadline)
122 }
123}
124
125func TestAuctionSetSlotDeadline(t *testing.T) {
126 newSlotDeadline := uint8(25)
127 if auctionClient != nil {
128 _, err := auctionClient.AuctionSetSlotDeadline(newSlotDeadline)
129 require.Nil(t, err)
130 slotDeadline, err := auctionClient.AuctionGetSlotDeadline()
131 require.Nil(t, err)
132 assert.Equal(t, newSlotDeadline, slotDeadline)
133 _, err = auctionClient.AuctionSetSlotDeadline(slotDeadlineConst)
134 require.Nil(t, err)
135 }
136}
137
138func TestAuctionGetOpenAuctionSlots(t *testing.T) {
139 if auctionClient != nil {
140 openAuctionSlots, err := auctionClient.AuctionGetOpenAuctionSlots()
141 require.Nil(t, err)
142 assert.Equal(t, openAuctionSlotsConst, openAuctionSlots)
143 }
144}
145
146func TestAuctionSetOpenAuctionSlots(t *testing.T) {
147 newOpenAuctionSlots := uint16(4500)
148 if auctionClient != nil {
149 _, err := auctionClient.AuctionSetOpenAuctionSlots(newOpenAuctionSlots)
150 require.Nil(t, err)
151 openAuctionSlots, err := auctionClient.AuctionGetOpenAuctionSlots()
152 require.Nil(t, err)
153 assert.Equal(t, newOpenAuctionSlots, openAuctionSlots)
154 _, err = auctionClient.AuctionSetOpenAuctionSlots(openAuctionSlotsConst)
155 require.Nil(t, err)
156 }
157}
158
159func TestAuctionGetClosedAuctionSlots(t *testing.T) {
160 if auctionClient != nil {
161 closedAuctionSlots, err := auctionClient.AuctionGetClosedAuctionSlots()
162 require.Nil(t, err)
163 assert.Equal(t, closedAuctionSlotsConst, closedAuctionSlots)
164 }
165}
166
167func TestAuctionSetClosedAuctionSlots(t *testing.T) {
168 newClosedAuctionSlots := uint16(5)
169 if auctionClient != nil {
170 _, err := auctionClient.AuctionSetClosedAuctionSlots(newClosedAuctionSlots)
171 require.Nil(t, err)
172 closedAuctionSlots, err := auctionClient.AuctionGetClosedAuctionSlots()
173 require.Nil(t, err)
174 assert.Equal(t, newClosedAuctionSlots, closedAuctionSlots)
175 _, err = auctionClient.AuctionSetClosedAuctionSlots(closedAuctionSlotsConst)
176 require.Nil(t, err)
177 }
178}
179
180func TestAuctionGetOutbidding(t *testing.T) {
181 if auctionClient != nil {
182 outbidding, err := auctionClient.AuctionGetOutbidding()
183 require.Nil(t, err)
184 assert.Equal(t, outbiddingConst, outbidding)
185 }
186}
187
188func TestAuctionSetOutbidding(t *testing.T) {
189 newOutbidding := uint16(0xb)
190 if auctionClient != nil {
191 _, err := auctionClient.AuctionSetOutbidding(newOutbidding)
192 require.Nil(t, err)
193 outbidding, err := auctionClient.AuctionGetOutbidding()
194 require.Nil(t, err)
195 assert.Equal(t, newOutbidding, outbidding)
196 _, err = auctionClient.AuctionSetOutbidding(outbiddingConst)
197 require.Nil(t, err)
198 }
199}
200
201func TestAuctionGetAllocationRatio(t *testing.T) {
202 if auctionClient != nil {
203 allocationRatio, err := auctionClient.AuctionGetAllocationRatio()
204 require.Nil(t, err)
205 assert.Equal(t, allocationRatioConst, allocationRatio)
206 }
207}
208
209func TestAuctionSetAllocationRatio(t *testing.T) {
210 newAllocationRatio := [3]uint16{3000, 3000, 4000}
211 if auctionClient != nil {
212 _, err := auctionClient.AuctionSetAllocationRatio(newAllocationRatio)
213 require.Nil(t, err)
214 allocationRatio, err := auctionClient.AuctionGetAllocationRatio()
215 require.Nil(t, err)
216 assert.Equal(t, newAllocationRatio, allocationRatio)
217 _, err = auctionClient.AuctionSetAllocationRatio(allocationRatioConst)
218 require.Nil(t, err)
219 }
220}
221
222func TestAuctionGetDonationAddress(t *testing.T) {
223 if auctionClient != nil {
224 donationAddress, err := auctionClient.AuctionGetDonationAddress()
225 require.Nil(t, err)
226 donationAddressConst := common.HexToAddress(donationAddressStr)
227 assert.Equal(t, &donationAddressConst, donationAddress)
228 }
229}
230
231func TestAuctionGetBootCoordinator(t *testing.T) {
232 if auctionClient != nil {
233 bootCoordinator, err := auctionClient.AuctionGetBootCoordinator()
234 require.Nil(t, err)
235 bootCoordinatorConst := common.HexToAddress(bootCoordinatorStr)
236 assert.Equal(t, &bootCoordinatorConst, bootCoordinator)
237 }
238}
239
240func TestAuctionSetDonationAddress(t *testing.T) {
241 newDonationAddress := common.HexToAddress(governanceAddressStr)
242 if auctionClient != nil {
243 _, err := auctionClient.AuctionSetDonationAddress(newDonationAddress)
244 require.Nil(t, err)
245 donationAddress, err := auctionClient.AuctionGetDonationAddress()
246 require.Nil(t, err)
247 assert.Equal(t, &newDonationAddress, donationAddress)
248 donationAddressConst := common.HexToAddress(donationAddressStr)
249 _, err = auctionClient.AuctionSetDonationAddress(donationAddressConst)
250 require.Nil(t, err)
251 }
252}
253
254func TestAuctionSetBootCoordinator(t *testing.T) {
255 newBootCoordinator := common.HexToAddress(governanceAddressStr)
256 if auctionClient != nil {
257 _, err := auctionClient.AuctionSetBootCoordinator(newBootCoordinator)
258 require.Nil(t, err)
259 bootCoordinator, err := auctionClient.AuctionGetBootCoordinator()
260 require.Nil(t, err)
261 assert.Equal(t, &newBootCoordinator, bootCoordinator)
262 bootCoordinatorConst := common.HexToAddress(bootCoordinatorStr)
263 _, err = auctionClient.AuctionSetBootCoordinator(bootCoordinatorConst)
264 require.Nil(t, err)
265 }
266}
267
268func TestAuctionGetSlotSet(t *testing.T) {
269 slot := int64(10)
270 if auctionClient != nil {
271 slotSet, err := auctionClient.AuctionGetSlotSet(slot)
272 require.Nil(t, err)
273 assert.Equal(t, slotSet, big.NewInt(4))
274 }
275}
276
277func TestAuctionGetDefaultSlotSetBid(t *testing.T) {
278 slotSet := uint8(3)
279 if auctionClient != nil {
280 minBid, err := auctionClient.AuctionGetDefaultSlotSetBid(slotSet)
281 require.Nil(t, err)
282 assert.Equal(t, minBid.String(), minBidStr)
283 }
284}
285
286func TestAuctionChangeDefaultSlotSetBid(t *testing.T) {
287 slotSet := int64(3)
288 set := uint8(3)
289 newInitialMinBid := new(big.Int)
290 newInitialMinBid.SetString("20000000000000000000", 10)
291 if auctionClient != nil {
292 _, err := auctionClient.AuctionChangeDefaultSlotSetBid(slotSet, newInitialMinBid)
293 require.Nil(t, err)
294 minBid, err := auctionClient.AuctionGetDefaultSlotSetBid(set)
295 require.Nil(t, err)
296 assert.Equal(t, minBid, newInitialMinBid)
297 newMinBid := new(big.Int)
298 newMinBid.SetString("10000000000000000000", 10)
299 _, err = auctionClient.AuctionChangeDefaultSlotSetBid(slotSet, newMinBid)
300 require.Nil(t, err)
301 }
302}
303
304func TestAuctionGetClaimableHEZ(t *testing.T) {
305 forgerAddress := common.HexToAddress(governanceAddressStr)
306 if auctionClient != nil {
307 claimableHEZ, err := auctionClient.AuctionGetClaimableHEZ(forgerAddress)
308 require.Nil(t, err)
309 assert.Equal(t, claimableHEZ.Int64(), int64(0))
310 }
311}
312
313func TestAuctionIsRegisteredCoordinator(t *testing.T) {
314 forgerAddress := common.HexToAddress(governanceAddressStr)
315 if auctionClient != nil {
316 registered, err := auctionClient.AuctionIsRegisteredCoordinator(forgerAddress)
317 require.Nil(t, err)
318 assert.Equal(t, registered, false)
319 }
320}
321
322func TestAuctionRegisterCoordinator(t *testing.T) {
323 forgerAddress := common.HexToAddress(governanceAddressStr)
324 if auctionClient != nil {
325 _, err := auctionClient.AuctionRegisterCoordinator(forgerAddress, URL)
326 require.Nil(t, err)
327 }
328}
329
330func TestAuctionIsRegisteredCoordinatorTrue(t *testing.T) {
331 forgerAddress := common.HexToAddress(governanceAddressStr)
332 if auctionClient != nil {
333 registered, err := auctionClient.AuctionIsRegisteredCoordinator(forgerAddress)
334 require.Nil(t, err)
335 assert.Equal(t, registered, true)
336 }
337}
338
339func TestAuctionUpdateCoordinatorInfo(t *testing.T) {
340 forgerAddress := common.HexToAddress(governanceAddressStr)
341 if auctionClient != nil {
342 _, err := auctionClient.AuctionUpdateCoordinatorInfo(forgerAddress, forgerAddress, newURL)
343 require.Nil(t, err)
344 }
345}
346
347func TestAuctionBid(t *testing.T) {
348 if auctionClient != nil {
349 currentSlot, err := auctionClient.AuctionGetCurrentSlotNumber()
350 require.Nil(t, err)
351 bidAmount := new(big.Int)
352 bidAmount.SetString("11000000000000000000", 10)
353 forgerAddress := common.HexToAddress(governanceAddressStr)
354 _, err = auctionClient.AuctionBid(currentSlot+4, bidAmount, forgerAddress, TOKENHEZ)
355 require.Nil(t, err)
356 }
357}
358
359func TestAuctionMultiBid(t *testing.T) {
360 if auctionClient != nil {
361 currentSlot, err := auctionClient.AuctionGetCurrentSlotNumber()
362 require.Nil(t, err)
363 slotSet := [6]bool{false, true, false, true, false, true}
364 maxBid := new(big.Int)
365 maxBid.SetString("11000000000000000000", 10)
366 minBid := new(big.Int)
367 minBid.SetString("11000000000000000000", 10)
368 budget := new(big.Int)
369 budget.SetString("110000000000000000000", 10)
370 forgerAddress := common.HexToAddress(governanceAddressStr)
371 _, err = auctionClient.AuctionMultiBid(currentSlot+5, currentSlot+10, slotSet, maxBid, minBid, budget, forgerAddress, TOKENHEZ)
372 require.Nil(t, err)
373 }
374}