hermez-node/eth/auction_test.go
eth/auction_test.goRaw
1package eth
2
3import (
4 "math/big"
5 "testing"
6
7 "github.com/stretchr/testify/assert"
8 "github.com/stretchr/testify/require"
9)
10
11const slotDeadlineConst = uint8(20)
12const openAuctionSlotsConst = uint16(4320)
13const closedAuctionSlotsConst = uint16(2)
14const outbiddingConst = uint16(1000)
15const currentSlotConst = 0
16const blocksPerSlot = uint8(40)
17const minBidStr = "10000000000000000000"
18const URL = "http://localhost:3000"
19
20var allocationRatioConst [3]uint16 = [3]uint16{4000, 4000, 2000}
21var auctionClientTest *AuctionClient
22
23func TestAuctionGetCurrentSlotNumber(t *testing.T) {
24 currentSlot, err := auctionClientTest.AuctionGetCurrentSlotNumber()
25 require.Nil(t, err)
26 currentSlotInt := int(currentSlot)
27 assert.Equal(t, currentSlotConst, currentSlotInt)
28}
29
30func TestAuctionEventInit(t *testing.T) {
31 auctionInit, blockNum, err := auctionClientTest.AuctionEventInit()
32 require.NoError(t, err)
33 assert.Equal(t, int64(18), blockNum)
34 assert.Equal(t, donationAddressConst, auctionInit.DonationAddress)
35 assert.Equal(t, bootCoordinatorAddressConst, auctionInit.BootCoordinatorAddress)
36 assert.Equal(t, "https://boot.coordinator.io", auctionInit.BootCoordinatorURL)
37 assert.Equal(t, uint16(1000), auctionInit.Outbidding)
38 assert.Equal(t, uint8(20), auctionInit.SlotDeadline)
39 assert.Equal(t, uint16(2), auctionInit.ClosedAuctionSlots)
40 assert.Equal(t, uint16(4320), auctionInit.OpenAuctionSlots)
41 assert.Equal(t, [3]uint16{4000, 4000, 2000}, auctionInit.AllocationRatio)
42}
43
44func TestAuctionConstants(t *testing.T) {
45 INITMINBID := new(big.Int)
46 INITMINBID.SetString(minBidStr, 10)
47
48 auctionConstants, err := auctionClientTest.AuctionConstants()
49 require.Nil(t, err)
50 assert.Equal(t, auctionConstants.BlocksPerSlot, blocksPerSlot)
51 assert.Equal(t, auctionConstants.GenesisBlockNum, genesisBlock)
52 assert.Equal(t, auctionConstants.HermezRollup, hermezRollupTestAddressConst)
53 assert.Equal(t, auctionConstants.InitialMinimalBidding, INITMINBID)
54 assert.Equal(t, auctionConstants.TokenHEZ, tokenHEZAddressConst)
55 assert.Equal(t, auctionConstants.GovernanceAddress, governanceAddressConst)
56}
57
58func TestAuctionVariables(t *testing.T) {
59 INITMINBID := new(big.Int)
60 INITMINBID.SetString(minBidStr, 10)
61 defaultSlotSetBid := [6]*big.Int{INITMINBID, INITMINBID, INITMINBID, INITMINBID, INITMINBID,
62 INITMINBID}
63
64 auctionVariables, err := auctionClientTest.AuctionVariables()
65 require.Nil(t, err)
66 assert.Equal(t, auctionVariables.AllocationRatio, allocationRatioConst)
67 assert.Equal(t, auctionVariables.BootCoordinator, bootCoordinatorAddressConst)
68 assert.Equal(t, auctionVariables.ClosedAuctionSlots, closedAuctionSlotsConst)
69 assert.Equal(t, auctionVariables.DefaultSlotSetBid, defaultSlotSetBid)
70 assert.Equal(t, auctionVariables.DonationAddress, donationAddressConst)
71 assert.Equal(t, auctionVariables.OpenAuctionSlots, openAuctionSlotsConst)
72 assert.Equal(t, auctionVariables.Outbidding, outbiddingConst)
73 assert.Equal(t, auctionVariables.SlotDeadline, slotDeadlineConst)
74}
75
76func TestAuctionGetSlotDeadline(t *testing.T) {
77 slotDeadline, err := auctionClientTest.AuctionGetSlotDeadline()
78 require.Nil(t, err)
79 assert.Equal(t, slotDeadlineConst, slotDeadline)
80}
81
82func TestAuctionSetSlotDeadline(t *testing.T) {
83 newSlotDeadline := uint8(25)
84
85 _, err := auctionClientTest.AuctionSetSlotDeadline(newSlotDeadline)
86 require.Nil(t, err)
87 slotDeadline, err := auctionClientTest.AuctionGetSlotDeadline()
88 require.Nil(t, err)
89 assert.Equal(t, newSlotDeadline, slotDeadline)
90 currentBlockNum, err := auctionClientTest.client.EthLastBlock()
91 require.Nil(t, err)
92 auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
93 require.Nil(t, err)
94 assert.Equal(t, newSlotDeadline, auctionEvents.NewSlotDeadline[0].NewSlotDeadline)
95}
96
97func TestAuctionGetOpenAuctionSlots(t *testing.T) {
98 openAuctionSlots, err := auctionClientTest.AuctionGetOpenAuctionSlots()
99 require.Nil(t, err)
100 assert.Equal(t, openAuctionSlotsConst, openAuctionSlots)
101}
102
103func TestAuctionSetOpenAuctionSlots(t *testing.T) {
104 newOpenAuctionSlots := uint16(4500)
105
106 _, err := auctionClientTest.AuctionSetOpenAuctionSlots(newOpenAuctionSlots)
107 require.Nil(t, err)
108 openAuctionSlots, err := auctionClientTest.AuctionGetOpenAuctionSlots()
109 require.Nil(t, err)
110 assert.Equal(t, newOpenAuctionSlots, openAuctionSlots)
111 currentBlockNum, err := auctionClientTest.client.EthLastBlock()
112 require.Nil(t, err)
113 auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
114 require.Nil(t, err)
115 assert.Equal(t, newOpenAuctionSlots, auctionEvents.NewOpenAuctionSlots[0].NewOpenAuctionSlots)
116}
117
118func TestAuctionGetClosedAuctionSlots(t *testing.T) {
119 closedAuctionSlots, err := auctionClientTest.AuctionGetClosedAuctionSlots()
120 require.Nil(t, err)
121 assert.Equal(t, closedAuctionSlotsConst, closedAuctionSlots)
122}
123
124func TestAuctionSetClosedAuctionSlots(t *testing.T) {
125 newClosedAuctionSlots := uint16(1)
126
127 _, err := auctionClientTest.AuctionSetClosedAuctionSlots(newClosedAuctionSlots)
128 require.Nil(t, err)
129 closedAuctionSlots, err := auctionClientTest.AuctionGetClosedAuctionSlots()
130 require.Nil(t, err)
131 assert.Equal(t, newClosedAuctionSlots, closedAuctionSlots)
132 currentBlockNum, err := auctionClientTest.client.EthLastBlock()
133 require.Nil(t, err)
134 auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
135 require.Nil(t, err)
136 assert.Equal(t, newClosedAuctionSlots,
137 auctionEvents.NewClosedAuctionSlots[0].NewClosedAuctionSlots)
138 _, err = auctionClientTest.AuctionSetClosedAuctionSlots(closedAuctionSlots)
139 require.Nil(t, err)
140}
141
142func TestAuctionGetOutbidding(t *testing.T) {
143 outbidding, err := auctionClientTest.AuctionGetOutbidding()
144 require.Nil(t, err)
145 assert.Equal(t, outbiddingConst, outbidding)
146}
147
148func TestAuctionSetOutbidding(t *testing.T) {
149 newOutbidding := uint16(0xb)
150
151 _, err := auctionClientTest.AuctionSetOutbidding(newOutbidding)
152 require.Nil(t, err)
153 outbidding, err := auctionClientTest.AuctionGetOutbidding()
154 require.Nil(t, err)
155 assert.Equal(t, newOutbidding, outbidding)
156 currentBlockNum, err := auctionClientTest.client.EthLastBlock()
157 require.Nil(t, err)
158 auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
159 require.Nil(t, err)
160 assert.Equal(t, newOutbidding, auctionEvents.NewOutbidding[0].NewOutbidding)
161 _, err = auctionClientTest.AuctionSetOutbidding(outbiddingConst)
162 require.Nil(t, err)
163}
164
165func TestAuctionGetAllocationRatio(t *testing.T) {
166 allocationRatio, err := auctionClientTest.AuctionGetAllocationRatio()
167 require.Nil(t, err)
168 assert.Equal(t, allocationRatioConst, allocationRatio)
169}
170
171func TestAuctionSetAllocationRatio(t *testing.T) {
172 newAllocationRatio := [3]uint16{3000, 3000, 4000}
173
174 _, err := auctionClientTest.AuctionSetAllocationRatio(newAllocationRatio)
175 require.Nil(t, err)
176 allocationRatio, err := auctionClientTest.AuctionGetAllocationRatio()
177 require.Nil(t, err)
178 assert.Equal(t, newAllocationRatio, allocationRatio)
179 currentBlockNum, err := auctionClientTest.client.EthLastBlock()
180 require.Nil(t, err)
181 auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
182 require.Nil(t, err)
183 assert.Equal(t, newAllocationRatio, auctionEvents.NewAllocationRatio[0].NewAllocationRatio)
184 _, err = auctionClientTest.AuctionSetAllocationRatio(allocationRatioConst)
185 require.Nil(t, err)
186}
187
188func TestAuctionGetDonationAddress(t *testing.T) {
189 donationAddress, err := auctionClientTest.AuctionGetDonationAddress()
190 require.Nil(t, err)
191 assert.Equal(t, &donationAddressConst, donationAddress)
192}
193
194func TestAuctionGetBootCoordinator(t *testing.T) {
195 bootCoordinator, err := auctionClientTest.AuctionGetBootCoordinator()
196 require.Nil(t, err)
197 assert.Equal(t, &bootCoordinatorAddressConst, bootCoordinator)
198}
199
200func TestAuctionSetDonationAddress(t *testing.T) {
201 newDonationAddress := governanceAddressConst
202
203 _, err := auctionClientTest.AuctionSetDonationAddress(newDonationAddress)
204 require.Nil(t, err)
205 donationAddress, err := auctionClientTest.AuctionGetDonationAddress()
206 require.Nil(t, err)
207 assert.Equal(t, &newDonationAddress, donationAddress)
208 currentBlockNum, err := auctionClientTest.client.EthLastBlock()
209 require.Nil(t, err)
210 auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
211 require.Nil(t, err)
212 assert.Equal(t, newDonationAddress, auctionEvents.NewDonationAddress[0].NewDonationAddress)
213 _, err = auctionClientTest.AuctionSetDonationAddress(donationAddressConst)
214 require.Nil(t, err)
215}
216
217func TestAuctionSetBootCoordinator(t *testing.T) {
218 newBootCoordinator := governanceAddressConst
219 bootCoordinatorURL := "https://boot.coordinator2.io"
220 newBootCoordinatorURL := "https://boot.coordinator2.io"
221
222 _, err := auctionClientTest.AuctionSetBootCoordinator(newBootCoordinator, newBootCoordinatorURL)
223 require.Nil(t, err)
224 bootCoordinator, err := auctionClientTest.AuctionGetBootCoordinator()
225 require.Nil(t, err)
226 assert.Equal(t, &newBootCoordinator, bootCoordinator)
227 currentBlockNum, err := auctionClientTest.client.EthLastBlock()
228 require.Nil(t, err)
229 auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
230 require.Nil(t, err)
231 assert.Equal(t, newBootCoordinator, auctionEvents.NewBootCoordinator[0].NewBootCoordinator)
232 assert.Equal(t, newBootCoordinatorURL, auctionEvents.NewBootCoordinator[0].NewBootCoordinatorURL)
233 _, err = auctionClientTest.AuctionSetBootCoordinator(bootCoordinatorAddressConst,
234 bootCoordinatorURL)
235 require.Nil(t, err)
236}
237
238func TestAuctionGetSlotSet(t *testing.T) {
239 slot := int64(10)
240
241 slotSet, err := auctionClientTest.AuctionGetSlotSet(slot)
242 require.Nil(t, err)
243 assert.Equal(t, slotSet, big.NewInt(4))
244}
245
246func TestAuctionGetDefaultSlotSetBid(t *testing.T) {
247 slotSet := uint8(3)
248
249 minBid, err := auctionClientTest.AuctionGetDefaultSlotSetBid(slotSet)
250 require.Nil(t, err)
251 assert.Equal(t, minBid.String(), minBidStr)
252}
253
254func TestAuctionChangeDefaultSlotSetBid(t *testing.T) {
255 slotSet := int64(3)
256 set := uint8(3)
257 newInitialMinBid := new(big.Int)
258 newInitialMinBid.SetString("20000000000000000000", 10)
259
260 _, err := auctionClientTest.AuctionChangeDefaultSlotSetBid(slotSet, newInitialMinBid)
261 require.Nil(t, err)
262 minBid, err := auctionClientTest.AuctionGetDefaultSlotSetBid(set)
263 require.Nil(t, err)
264 assert.Equal(t, minBid, newInitialMinBid)
265 currentBlockNum, err := auctionClientTest.client.EthLastBlock()
266 require.Nil(t, err)
267 auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
268 require.Nil(t, err)
269 assert.Equal(t, slotSet, auctionEvents.NewDefaultSlotSetBid[0].SlotSet)
270 assert.Equal(t, newInitialMinBid, auctionEvents.NewDefaultSlotSetBid[0].NewInitialMinBid)
271 newMinBid := new(big.Int)
272 newMinBid.SetString("10000000000000000000", 10)
273 _, err = auctionClientTest.AuctionChangeDefaultSlotSetBid(slotSet, newMinBid)
274 require.Nil(t, err)
275}
276
277func TestAuctionGetClaimableHEZ(t *testing.T) {
278 bidderAddress := governanceAddressConst
279
280 claimableHEZ, err := auctionClientTest.AuctionGetClaimableHEZ(bidderAddress)
281 require.Nil(t, err)
282 assert.Equal(t, claimableHEZ.Int64(), int64(0))
283}
284
285func TestAuctionRegisterCoordinator(t *testing.T) {
286 forgerAddress := governanceAddressConst
287 bidderAddress := governanceAddressConst
288
289 _, err := auctionClientTest.AuctionSetCoordinator(forgerAddress, URL)
290 require.Nil(t, err)
291 currentBlockNum, err := auctionClientTest.client.EthLastBlock()
292 require.Nil(t, err)
293 auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
294 require.Nil(t, err)
295 assert.Equal(t, forgerAddress, auctionEvents.SetCoordinator[0].ForgerAddress)
296 assert.Equal(t, bidderAddress, auctionEvents.SetCoordinator[0].BidderAddress)
297 assert.Equal(t, URL, auctionEvents.SetCoordinator[0].CoordinatorURL)
298}
299
300func TestAuctionBid(t *testing.T) {
301 currentSlot, err := auctionClientTest.AuctionGetCurrentSlotNumber()
302 require.Nil(t, err)
303 bidAmount := new(big.Int)
304 bidAmount.SetString("12000000000000000000", 10)
305 amount := new(big.Int)
306 amount.SetString("12000000000000000000", 10)
307 bidderAddress := governanceAddressConst
308 _, err = auctionClientTest.AuctionBid(amount, currentSlot+4, bidAmount, deadline)
309 require.Nil(t, err)
310 currentBlockNum, err := auctionClientTest.client.EthLastBlock()
311 require.Nil(t, err)
312 auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
313 require.Nil(t, err)
314 assert.Equal(t, bidAmount, auctionEvents.NewBid[0].BidAmount)
315 assert.Equal(t, bidderAddress, auctionEvents.NewBid[0].Bidder)
316 assert.Equal(t, currentSlot+4, auctionEvents.NewBid[0].Slot)
317}
318
319func TestAuctionGetSlotNumber(t *testing.T) {
320 slotConst := 4
321 blockNum := int(blocksPerSlot)*slotConst + int(genesisBlock)
322
323 slot, err := auctionClientTest.AuctionGetSlotNumber(int64(blockNum))
324 require.Nil(t, err)
325 assert.Equal(t, slot, int64(slotConst))
326}
327
328func TestAuctionCanForge(t *testing.T) {
329 slotConst := 4
330 blockNum := int(blocksPerSlot)*slotConst + int(genesisBlock)
331
332 canForge, err := auctionClientTest.AuctionCanForge(governanceAddressConst, int64(blockNum))
333 require.Nil(t, err)
334 assert.Equal(t, canForge, true)
335}
336
337func TestAuctionMultiBid(t *testing.T) {
338 currentSlot, err := auctionClientTest.AuctionGetCurrentSlotNumber()
339 require.Nil(t, err)
340 slotSet := [6]bool{true, false, true, false, true, false}
341 maxBid := new(big.Int)
342 maxBid.SetString("15000000000000000000", 10)
343 minBid := new(big.Int)
344 minBid.SetString("11000000000000000000", 10)
345 budget := new(big.Int)
346 budget.SetString("45200000000000000000", 10)
347 bidderAddress := governanceAddressConst
348 _, err = auctionClientTest.AuctionMultiBid(budget, currentSlot+4, currentSlot+10, slotSet,
349 maxBid, minBid, deadline)
350 require.Nil(t, err)
351 currentBlockNum, err := auctionClientTest.client.EthLastBlock()
352 require.Nil(t, err)
353 auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
354 require.Nil(t, err)
355 assert.Equal(t, bidderAddress, auctionEvents.NewBid[0].Bidder)
356 assert.Equal(t, currentSlot+4, auctionEvents.NewBid[0].Slot)
357 assert.Equal(t, bidderAddress, auctionEvents.NewBid[1].Bidder)
358 assert.Equal(t, currentSlot+6, auctionEvents.NewBid[1].Slot)
359 assert.Equal(t, bidderAddress, auctionEvents.NewBid[2].Bidder)
360 assert.Equal(t, currentSlot+8, auctionEvents.NewBid[2].Slot)
361 assert.Equal(t, bidderAddress, auctionEvents.NewBid[3].Bidder)
362 assert.Equal(t, currentSlot+10, auctionEvents.NewBid[3].Slot)
363}
364
365func TestAuctionGetClaimableHEZ2(t *testing.T) {
366 bidderAddress := governanceAddressConst
367 amount := new(big.Int)
368 amount.SetString("11000000000000000000", 10)
369
370 claimableHEZ, err := auctionClientTest.AuctionGetClaimableHEZ(bidderAddress)
371 require.Nil(t, err)
372 assert.Equal(t, claimableHEZ, amount)
373}
374
375func TestAuctionClaimHEZ(t *testing.T) {
376 amount := new(big.Int)
377 amount.SetString("11000000000000000000", 10)
378
379 _, err := auctionClientTest.AuctionClaimHEZ()
380 require.Nil(t, err)
381 currentBlockNum, err := auctionClientTest.client.EthLastBlock()
382 require.Nil(t, err)
383 auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
384 require.Nil(t, err)
385 assert.Equal(t, amount, auctionEvents.HEZClaimed[0].Amount)
386 assert.Equal(t, governanceAddressConst, auctionEvents.HEZClaimed[0].Owner)
387}
388
389func TestAuctionForge(t *testing.T) {
390 auctionClientTestHermez, err := NewAuctionClient(ethereumClientHermez,
391 auctionTestAddressConst, tokenHEZ)
392 require.Nil(t, err)
393 slotConst := 4
394 blockNum := int64(int(blocksPerSlot)*slotConst + int(genesisBlock))
395 currentBlockNum, err := auctionClientTestHermez.client.EthLastBlock()
396 require.Nil(t, err)
397 blocksToAdd := blockNum - currentBlockNum
398 addBlocks(blocksToAdd, ethClientDialURL)
399 currentBlockNum, err = auctionClientTestHermez.client.EthLastBlock()
400 require.Nil(t, err)
401 assert.Equal(t, currentBlockNum, blockNum)
402 _, err = auctionClientTestHermez.AuctionForge(governanceAddressConst)
403 require.Nil(t, err)
404}