hermez-node/eth/auction_test.go
eth/auction_test.goRaw
1package eth
2
3import (
4 "math/big"
5 "os"
6 "testing"
7
8 "github.com/ethereum/go-ethereum/accounts/keystore"
9 "github.com/ethereum/go-ethereum/common"
10 "github.com/ethereum/go-ethereum/crypto"
11 "github.com/ethereum/go-ethereum/ethclient"
12 "github.com/stretchr/testify/assert"
13 "github.com/stretchr/testify/require"
14)
15
16const slotDeadlineConst = uint8(20)
17const openAuctionSlotsConst = uint16(4320)
18const closedAuctionSlotsConst = uint16(2)
19const outbiddingConst = uint16(1000)
20const currentSlotConst = 0
21
22var allocationRatioConst [3]uint16 = [3]uint16{4000, 4000, 2000}
23
24var auctionClient *AuctionClient
25
26/*var donationAddressStr = os.Getenv("DONATION_ADDRESS")
27var bootCoordinatorStr = os.Getenv("BOOT_COORDINATOR_ADDRESS")
28var ehtClientDialURL = os.Getenv("ETHCLIENT_DIAL_URL")
29var auctionAddressStr = os.Getenv("AUCTION_ADDRESS")*/
30var integration = os.Getenv("INTEGRATION")
31
32var donationAddressStr = "0x6c365935CA8710200C7595F0a72EB6023A7706Cd"
33var bootCoordinatorStr = "0xc783df8a850f42e7f7e57013759c285caa701eb6"
34var DONATION = common.HexToAddress(donationAddressStr)
35var BOOTCOORDINATOR = common.HexToAddress(bootCoordinatorStr)
36
37var ehtClientDialURL = "http://localhost:8545"
38var auctionAddressStr = "0x3619DbE27d7c1e7E91aA738697Ae7Bc5FC3eACA5"
39var ownerAddressStr = "0xc783df8a850f42e7F7e57013759C285caa701eB6"
40var governanceAddressStr = "0xead9c93b79ae7c1591b1fb5323bd777e86e150d4"
41var governancePrivateKey = "d49743deccbccc5dc7baa8e69e5be03298da8688a15dd202e20f15d5e0e9a9fb"
42var minBidStr = "10000000000000000000"
43var URL = "http://localhost:3000"
44var newURL = "http://localhost:3002"
45var BLOCKSPERSLOT = uint8(40)
46var TOKENHEZ = common.HexToAddress("0xf4e77E5Da47AC3125140c470c71cBca77B5c638c")
47var HERMEZROLLUP = common.HexToAddress("0xc4905364b78a742ccce7B890A89514061E47068D")
48
49var pathKs = "test/ks"
50var password = "pass"
51
52func TestNewAction(t *testing.T) {
53 key, err := crypto.HexToECDSA(governancePrivateKey)
54 require.Nil(t, err)
55 ks := keystore.NewKeyStore(pathKs, keystore.StandardScryptN, keystore.StandardScryptP)
56 account, err := ks.ImportECDSA(key, password)
57 ks.Unlock(account, password)
58 // Init eth client
59 ethClient, err := ethclient.Dial(ehtClientDialURL)
60 require.Nil(t, err)
61 ethereumClient := NewEthereumClient(ethClient, &account, ks, nil)
62 auctionAddress := common.HexToAddress(auctionAddressStr)
63 if integration != "" {
64 auctionClient = NewAuctionClient(ethereumClient, auctionAddress)
65 }
66}
67
68func TestAuctionGetCurrentSlotNumber(t *testing.T) {
69 if auctionClient != nil {
70 currentSlot, err := auctionClient.AuctionGetCurrentSlotNumber()
71 require.Nil(t, err)
72 currentSlotInt := int(currentSlot)
73 assert.Equal(t, currentSlotConst, currentSlotInt)
74 }
75}
76
77func TestAuctionConstants(t *testing.T) {
78 INITMINBID := new(big.Int)
79 INITMINBID.SetString(minBidStr, 10)
80 if auctionClient != nil {
81 auctionConstants, err := auctionClient.AuctionConstants()
82 require.Nil(t, err)
83 assert.Equal(t, auctionConstants.BlocksPerSlot, BLOCKSPERSLOT)
84 // assert.Equal(t, auctionConstants.GenesisBlockNum, GENESISBLOCKNUM)
85 assert.Equal(t, auctionConstants.HermezRollup, HERMEZROLLUP)
86 assert.Equal(t, auctionConstants.InitialMinimalBidding, INITMINBID)
87 assert.Equal(t, auctionConstants.TokenHEZ, TOKENHEZ)
88 }
89}
90
91func TestAuctionVariables(t *testing.T) {
92 INITMINBID := new(big.Int)
93 INITMINBID.SetString(minBidStr, 10)
94 defaultSlotSetBid := [6]*big.Int{INITMINBID, INITMINBID, INITMINBID, INITMINBID, INITMINBID, INITMINBID}
95 if auctionClient != nil {
96 auctionVariables, err := auctionClient.AuctionVariables()
97 require.Nil(t, err)
98 assert.Equal(t, auctionVariables.AllocationRatio, allocationRatioConst)
99 assert.Equal(t, auctionVariables.BootCoordinator, &BOOTCOORDINATOR)
100 assert.Equal(t, auctionVariables.ClosedAuctionSlots, closedAuctionSlotsConst)
101 assert.Equal(t, auctionVariables.DefaultSlotSetBid, defaultSlotSetBid)
102 assert.Equal(t, auctionVariables.DonationAddress, &DONATION)
103 assert.Equal(t, auctionVariables.OpenAuctionSlots, openAuctionSlotsConst)
104 assert.Equal(t, auctionVariables.Outbidding, outbiddingConst)
105 assert.Equal(t, auctionVariables.SlotDeadline, slotDeadlineConst)
106 }
107}
108
109func TestAuctionGetSlotDeadline(t *testing.T) {
110 if auctionClient != nil {
111 slotDeadline, err := auctionClient.AuctionGetSlotDeadline()
112 require.Nil(t, err)
113 assert.Equal(t, slotDeadlineConst, slotDeadline)
114 }
115}
116
117func TestAuctionSetSlotDeadline(t *testing.T) {
118 newSlotDeadline := uint8(25)
119 if auctionClient != nil {
120 _, err := auctionClient.AuctionSetSlotDeadline(newSlotDeadline)
121 require.Nil(t, err)
122 slotDeadline, err := auctionClient.AuctionGetSlotDeadline()
123 assert.Equal(t, newSlotDeadline, slotDeadline)
124 _, err = auctionClient.AuctionSetSlotDeadline(slotDeadlineConst)
125 require.Nil(t, err)
126 }
127}
128
129func TestAuctionGetOpenAuctionSlots(t *testing.T) {
130 if auctionClient != nil {
131 openAuctionSlots, err := auctionClient.AuctionGetOpenAuctionSlots()
132 require.Nil(t, err)
133 assert.Equal(t, openAuctionSlotsConst, openAuctionSlots)
134 }
135}
136
137func TestAuctionSetOpenAuctionSlots(t *testing.T) {
138 newOpenAuctionSlots := uint16(4500)
139 if auctionClient != nil {
140 _, err := auctionClient.AuctionSetOpenAuctionSlots(newOpenAuctionSlots)
141 require.Nil(t, err)
142 openAuctionSlots, err := auctionClient.AuctionGetOpenAuctionSlots()
143 assert.Equal(t, newOpenAuctionSlots, openAuctionSlots)
144 _, err = auctionClient.AuctionSetOpenAuctionSlots(openAuctionSlotsConst)
145 require.Nil(t, err)
146 }
147}
148
149func TestAuctionGetClosedAuctionSlots(t *testing.T) {
150 if auctionClient != nil {
151 closedAuctionSlots, err := auctionClient.AuctionGetClosedAuctionSlots()
152 require.Nil(t, err)
153 assert.Equal(t, closedAuctionSlotsConst, closedAuctionSlots)
154 }
155}
156
157func TestAuctionSetClosedAuctionSlots(t *testing.T) {
158 newClosedAuctionSlots := uint16(5)
159 if auctionClient != nil {
160 _, err := auctionClient.AuctionSetClosedAuctionSlots(newClosedAuctionSlots)
161 require.Nil(t, err)
162 closedAuctionSlots, err := auctionClient.AuctionGetClosedAuctionSlots()
163 assert.Equal(t, newClosedAuctionSlots, closedAuctionSlots)
164 _, err = auctionClient.AuctionSetClosedAuctionSlots(closedAuctionSlotsConst)
165 require.Nil(t, err)
166 }
167}
168
169func TestAuctionGetOutbidding(t *testing.T) {
170 if auctionClient != nil {
171 outbidding, err := auctionClient.AuctionGetOutbidding()
172 require.Nil(t, err)
173 assert.Equal(t, outbiddingConst, outbidding)
174 }
175}
176
177func TestAuctionSetOutbidding(t *testing.T) {
178 newOutbidding := uint16(0xb)
179 if auctionClient != nil {
180 _, err := auctionClient.AuctionSetOutbidding(newOutbidding)
181 require.Nil(t, err)
182 outbidding, err := auctionClient.AuctionGetOutbidding()
183 assert.Equal(t, newOutbidding, outbidding)
184 _, err = auctionClient.AuctionSetOutbidding(outbiddingConst)
185 require.Nil(t, err)
186 }
187}
188
189func TestAuctionGetAllocationRatio(t *testing.T) {
190 if auctionClient != nil {
191 allocationRatio, err := auctionClient.AuctionGetAllocationRatio()
192 require.Nil(t, err)
193 assert.Equal(t, allocationRatioConst, allocationRatio)
194 }
195}
196
197func TestAuctionSetAllocationRatio(t *testing.T) {
198 newAllocationRatio := [3]uint16{3000, 3000, 4000}
199 if auctionClient != nil {
200 _, err := auctionClient.AuctionSetAllocationRatio(newAllocationRatio)
201 require.Nil(t, err)
202 allocationRatio, err := auctionClient.AuctionGetAllocationRatio()
203 assert.Equal(t, newAllocationRatio, allocationRatio)
204 _, err = auctionClient.AuctionSetAllocationRatio(allocationRatioConst)
205 require.Nil(t, err)
206 }
207}
208
209func TestAuctionGetDonationAddress(t *testing.T) {
210 if auctionClient != nil {
211 donationAddress, err := auctionClient.AuctionGetDonationAddress()
212 require.Nil(t, err)
213 donationAddressConst := common.HexToAddress(donationAddressStr)
214 assert.Equal(t, &donationAddressConst, donationAddress)
215 }
216}
217
218func TestAuctionGetBootCoordinator(t *testing.T) {
219 if auctionClient != nil {
220 bootCoordinator, err := auctionClient.AuctionGetBootCoordinator()
221 require.Nil(t, err)
222 bootCoordinatorConst := common.HexToAddress(bootCoordinatorStr)
223 assert.Equal(t, &bootCoordinatorConst, bootCoordinator)
224 }
225}
226
227func TestAuctionSetDonationAddress(t *testing.T) {
228 newDonationAddress := common.HexToAddress(governanceAddressStr)
229 if auctionClient != nil {
230 _, err := auctionClient.AuctionSetDonationAddress(newDonationAddress)
231 require.Nil(t, err)
232 donationAddress, err := auctionClient.AuctionGetDonationAddress()
233 assert.Equal(t, &newDonationAddress, donationAddress)
234 donationAddressConst := common.HexToAddress(donationAddressStr)
235 _, err = auctionClient.AuctionSetDonationAddress(donationAddressConst)
236 require.Nil(t, err)
237 }
238}
239
240func TestAuctionSetBootCoordinator(t *testing.T) {
241 newBootCoordinator := common.HexToAddress(governanceAddressStr)
242 if auctionClient != nil {
243 _, err := auctionClient.AuctionSetBootCoordinator(newBootCoordinator)
244 require.Nil(t, err)
245 bootCoordinator, err := auctionClient.AuctionGetBootCoordinator()
246 assert.Equal(t, &newBootCoordinator, bootCoordinator)
247 bootCoordinatorConst := common.HexToAddress(bootCoordinatorStr)
248 _, err = auctionClient.AuctionSetBootCoordinator(bootCoordinatorConst)
249 require.Nil(t, err)
250 }
251}
252
253func TestAuctionGetDefaultSlotSetBid(t *testing.T) {
254 slotSet := uint8(3)
255 if auctionClient != nil {
256 minBid, err := auctionClient.AuctionGetDefaultSlotSetBid(slotSet)
257 require.Nil(t, err)
258 assert.Equal(t, minBid.String(), minBidStr)
259 }
260}
261
262func TestAuctionChangeEpochMinBid(t *testing.T) {
263 slotSet := int64(3)
264 set := uint8(3)
265 newInitialMinBid := new(big.Int)
266 newInitialMinBid.SetString("20000000000000000000", 10)
267 if auctionClient != nil {
268 _, err := auctionClient.AuctionChangeDefaultSlotSetBid(slotSet, newInitialMinBid)
269 require.Nil(t, err)
270 minBid, err := auctionClient.AuctionGetDefaultSlotSetBid(set)
271 require.Nil(t, err)
272 assert.Equal(t, minBid, newInitialMinBid)
273 newMinBid := new(big.Int)
274 newMinBid.SetString("10000000000000000000", 10)
275 _, err = auctionClient.AuctionChangeDefaultSlotSetBid(slotSet, newMinBid)
276 require.Nil(t, err)
277 }
278}
279
280func TestAuctionIsRegisteredCoordinator(t *testing.T) {
281 forgerAddress := common.HexToAddress(governanceAddressStr)
282 if auctionClient != nil {
283 registered, err := auctionClient.AuctionIsRegisteredCoordinator(forgerAddress)
284 require.Nil(t, err)
285 assert.Equal(t, registered, false)
286 }
287}
288
289func TestAuctionRegisterCoordinator(t *testing.T) {
290 forgerAddress := common.HexToAddress(governanceAddressStr)
291 if auctionClient != nil {
292 _, err := auctionClient.AuctionRegisterCoordinator(forgerAddress, URL)
293 require.Nil(t, err)
294 }
295}
296
297func TestAuctionIsRegisteredCoordinatorTrue(t *testing.T) {
298 forgerAddress := common.HexToAddress(governanceAddressStr)
299 if auctionClient != nil {
300 registered, err := auctionClient.AuctionIsRegisteredCoordinator(forgerAddress)
301 require.Nil(t, err)
302 assert.Equal(t, registered, true)
303 }
304}
305
306func TestAuctionUpdateCoordinatorInfo(t *testing.T) {
307 forgerAddress := common.HexToAddress(governanceAddressStr)
308 if auctionClient != nil {
309 _, err := auctionClient.AuctionUpdateCoordinatorInfo(forgerAddress, forgerAddress, newURL)
310 require.Nil(t, err)
311 }
312}