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