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