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