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