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