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