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