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