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 = 100
 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	bidderAddress := governanceAddressConst
274	_, err = auctionClientTest.AuctionBid(currentSlot+4, bidAmount)
275	require.Nil(t, err)
276	currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
277	auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
278	assert.Equal(t, bidAmount, auctionEvents.NewBid[0].BidAmount)
279	assert.Equal(t, bidderAddress, auctionEvents.NewBid[0].Bidder)
280	assert.Equal(t, currentSlot+4, auctionEvents.NewBid[0].Slot)
281}
282
283func TestAuctionGetSlotNumber(t *testing.T) {
284	slotConst := 4
285	blockNum := int(BLOCKSPERSLOT)*slotConst + genesisBlock
286
287	slot, err := auctionClientTest.AuctionGetSlotNumber(int64(blockNum))
288	require.Nil(t, err)
289	assert.Equal(t, slot, int64(slotConst))
290}
291
292func TestAuctionCanForge(t *testing.T) {
293	slotConst := 4
294	blockNum := int(BLOCKSPERSLOT)*slotConst + genesisBlock
295
296	canForge, err := auctionClientTest.AuctionCanForge(governanceAddressConst, int64(blockNum))
297	require.Nil(t, err)
298	assert.Equal(t, canForge, true)
299}
300
301func TestAuctionMultiBid(t *testing.T) {
302	currentSlot, err := auctionClientTest.AuctionGetCurrentSlotNumber()
303	require.Nil(t, err)
304	slotSet := [6]bool{true, false, true, false, true, false}
305	maxBid := new(big.Int)
306	maxBid.SetString("15000000000000000000", 10)
307	minBid := new(big.Int)
308	minBid.SetString("11000000000000000000", 10)
309	budget := new(big.Int)
310	budget.SetString("45200000000000000000", 10)
311	bidderAddress := governanceAddressConst
312	_, err = auctionClientTest.AuctionMultiBid(currentSlot+4, currentSlot+10, slotSet, maxBid, minBid, budget)
313	require.Nil(t, err)
314	currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
315	auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
316	assert.Equal(t, bidderAddress, auctionEvents.NewBid[0].Bidder)
317	assert.Equal(t, currentSlot+4, auctionEvents.NewBid[0].Slot)
318	assert.Equal(t, bidderAddress, auctionEvents.NewBid[1].Bidder)
319	assert.Equal(t, currentSlot+6, auctionEvents.NewBid[1].Slot)
320	assert.Equal(t, bidderAddress, auctionEvents.NewBid[2].Bidder)
321	assert.Equal(t, currentSlot+8, auctionEvents.NewBid[2].Slot)
322	assert.Equal(t, bidderAddress, auctionEvents.NewBid[3].Bidder)
323	assert.Equal(t, currentSlot+10, auctionEvents.NewBid[3].Slot)
324}
325
326func TestAuctionGetClaimableHEZ2(t *testing.T) {
327	bidderAddress := governanceAddressConst
328	amount := new(big.Int)
329	amount.SetString("11000000000000000000", 10)
330
331	claimableHEZ, err := auctionClientTest.AuctionGetClaimableHEZ(bidderAddress)
332	require.Nil(t, err)
333	assert.Equal(t, claimableHEZ, amount)
334}
335
336func TestAuctionClaimHEZ(t *testing.T) {
337	amount := new(big.Int)
338	amount.SetString("11000000000000000000", 10)
339
340	_, err := auctionClientTest.AuctionClaimHEZ()
341	require.Nil(t, err)
342	currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
343	auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
344	assert.Equal(t, amount, auctionEvents.HEZClaimed[0].Amount)
345	assert.Equal(t, governanceAddressConst, auctionEvents.HEZClaimed[0].Owner)
346}
347
348func TestAuctionForge(t *testing.T) {
349	auctionClientTestHermez, err := NewAuctionClient(ethereumClientHermez, auctionTestAddressConst, tokenHEZAddressConst)
350	require.Nil(t, err)
351	slotConst := 4
352	blockNum := int64(int(BLOCKSPERSLOT)*slotConst + genesisBlock)
353	currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
354	blocksToAdd := blockNum - currentBlockNum
355	addBlocks(blocksToAdd, ethClientDialURL)
356	currentBlockNum, _ = auctionClientTest.client.EthCurrentBlock()
357	assert.Equal(t, currentBlockNum, blockNum)
358	_, err = auctionClientTestHermez.AuctionForge(bootCoordinatorAddressConst)
359	require.Contains(t, err.Error(), "Can't forge")
360	_, err = auctionClientTestHermez.AuctionForge(governanceAddressConst)
361	require.Nil(t, err)
362}