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