1package eth
  2
  3import (
  4	"context"
  5	"math/big"
  6	"testing"
  7
  8	"github.com/stretchr/testify/assert"
  9	"github.com/stretchr/testify/require"
 10)
 11
 12const slotDeadlineConst = uint8(20)
 13const openAuctionSlotsConst = uint16(4320)
 14const closedAuctionSlotsConst = uint16(2)
 15const outbiddingConst = uint16(1000)
 16const currentSlotConst = 0
 17
 18var allocationRatioConst [3]uint16 = [3]uint16{4000, 4000, 2000}
 19
 20var auctionClient *AuctionClient
 21
 22var genesisBlock = 91
 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 := auctionClient.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 := auctionClient.AuctionConstants()
 41	require.Nil(t, err)
 42	assert.Equal(t, auctionConstants.BlocksPerSlot, BLOCKSPERSLOT)
 43	// assert.Equal(t, auctionConstants.GenesisBlockNum, GENESISBLOCKNUM)
 44	assert.Equal(t, auctionConstants.HermezRollup, hermezRollupAddressConst)
 45	assert.Equal(t, auctionConstants.InitialMinimalBidding, INITMINBID)
 46	assert.Equal(t, auctionConstants.TokenHEZ, tokenHezAddressConst)
 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 := auctionClient.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 := auctionClient.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 := auctionClient.AuctionSetSlotDeadline(newSlotDeadline)
 76	require.Nil(t, err)
 77	slotDeadline, err := auctionClient.AuctionGetSlotDeadline()
 78	require.Nil(t, err)
 79	assert.Equal(t, newSlotDeadline, slotDeadline)
 80	header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil)
 81	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64())
 82	assert.Equal(t, newSlotDeadline, auctionEvents.NewSlotDeadline[0].NewSlotDeadline)
 83}
 84
 85func TestAuctionGetOpenAuctionSlots(t *testing.T) {
 86	openAuctionSlots, err := auctionClient.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 := auctionClient.AuctionSetOpenAuctionSlots(newOpenAuctionSlots)
 95	require.Nil(t, err)
 96	openAuctionSlots, err := auctionClient.AuctionGetOpenAuctionSlots()
 97	require.Nil(t, err)
 98	assert.Equal(t, newOpenAuctionSlots, openAuctionSlots)
 99	header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil)
100	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64())
101	assert.Equal(t, newOpenAuctionSlots, auctionEvents.NewOpenAuctionSlots[0].NewOpenAuctionSlots)
102}
103
104func TestAuctionGetClosedAuctionSlots(t *testing.T) {
105	closedAuctionSlots, err := auctionClient.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 := auctionClient.AuctionSetClosedAuctionSlots(newClosedAuctionSlots)
114	require.Nil(t, err)
115	closedAuctionSlots, err := auctionClient.AuctionGetClosedAuctionSlots()
116	require.Nil(t, err)
117	assert.Equal(t, newClosedAuctionSlots, closedAuctionSlots)
118	header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil)
119	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64())
120	assert.Equal(t, newClosedAuctionSlots, auctionEvents.NewClosedAuctionSlots[0].NewClosedAuctionSlots)
121	_, err = auctionClient.AuctionSetClosedAuctionSlots(closedAuctionSlots)
122	require.Nil(t, err)
123}
124
125func TestAuctionGetOutbidding(t *testing.T) {
126	outbidding, err := auctionClient.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 := auctionClient.AuctionSetOutbidding(newOutbidding)
135	require.Nil(t, err)
136	outbidding, err := auctionClient.AuctionGetOutbidding()
137	require.Nil(t, err)
138	assert.Equal(t, newOutbidding, outbidding)
139	header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil)
140	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64())
141	assert.Equal(t, newOutbidding, auctionEvents.NewOutbidding[0].NewOutbidding)
142	_, err = auctionClient.AuctionSetOutbidding(outbiddingConst)
143	require.Nil(t, err)
144}
145
146func TestAuctionGetAllocationRatio(t *testing.T) {
147	allocationRatio, err := auctionClient.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 := auctionClient.AuctionSetAllocationRatio(newAllocationRatio)
156	require.Nil(t, err)
157	allocationRatio, err := auctionClient.AuctionGetAllocationRatio()
158	require.Nil(t, err)
159	assert.Equal(t, newAllocationRatio, allocationRatio)
160	header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil)
161	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64())
162	assert.Equal(t, newAllocationRatio, auctionEvents.NewAllocationRatio[0].NewAllocationRatio)
163	_, err = auctionClient.AuctionSetAllocationRatio(allocationRatioConst)
164	require.Nil(t, err)
165}
166
167func TestAuctionGetDonationAddress(t *testing.T) {
168	donationAddress, err := auctionClient.AuctionGetDonationAddress()
169	require.Nil(t, err)
170	assert.Equal(t, &donationAddressConst, donationAddress)
171}
172
173func TestAuctionGetBootCoordinator(t *testing.T) {
174	bootCoordinator, err := auctionClient.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 := auctionClient.AuctionSetDonationAddress(newDonationAddress)
183	require.Nil(t, err)
184	donationAddress, err := auctionClient.AuctionGetDonationAddress()
185	require.Nil(t, err)
186	assert.Equal(t, &newDonationAddress, donationAddress)
187	header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil)
188	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64())
189	assert.Equal(t, newDonationAddress, auctionEvents.NewDonationAddress[0].NewDonationAddress)
190	_, err = auctionClient.AuctionSetDonationAddress(donationAddressConst)
191	require.Nil(t, err)
192}
193
194func TestAuctionSetBootCoordinator(t *testing.T) {
195	newBootCoordinator := governanceAddressConst
196
197	_, err := auctionClient.AuctionSetBootCoordinator(newBootCoordinator)
198	require.Nil(t, err)
199	bootCoordinator, err := auctionClient.AuctionGetBootCoordinator()
200	require.Nil(t, err)
201	assert.Equal(t, &newBootCoordinator, bootCoordinator)
202	header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil)
203	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64())
204	assert.Equal(t, newBootCoordinator, auctionEvents.NewBootCoordinator[0].NewBootCoordinator)
205	_, err = auctionClient.AuctionSetBootCoordinator(bootCoordinatorAddressConst)
206	require.Nil(t, err)
207}
208
209func TestAuctionGetSlotSet(t *testing.T) {
210	slot := int64(10)
211
212	slotSet, err := auctionClient.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 := auctionClient.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 := auctionClient.AuctionChangeDefaultSlotSetBid(slotSet, newInitialMinBid)
232	require.Nil(t, err)
233	minBid, err := auctionClient.AuctionGetDefaultSlotSetBid(set)
234	require.Nil(t, err)
235	assert.Equal(t, minBid, newInitialMinBid)
236	header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil)
237	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64())
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 = auctionClient.AuctionChangeDefaultSlotSetBid(slotSet, newMinBid)
243	require.Nil(t, err)
244}
245
246func TestAuctionGetClaimableHEZ(t *testing.T) {
247	forgerAddress := governanceAddressConst
248
249	claimableHEZ, err := auctionClient.AuctionGetClaimableHEZ(forgerAddress)
250	require.Nil(t, err)
251	assert.Equal(t, claimableHEZ.Int64(), int64(0))
252}
253
254func TestAuctionIsRegisteredCoordinator(t *testing.T) {
255	forgerAddress := governanceAddressConst
256
257	registered, err := auctionClient.AuctionIsRegisteredCoordinator(forgerAddress)
258	require.Nil(t, err)
259	assert.Equal(t, registered, false)
260}
261
262func TestAuctionRegisterCoordinator(t *testing.T) {
263	forgerAddress := governanceAddressConst
264
265	_, err := auctionClient.AuctionRegisterCoordinator(forgerAddress, URL)
266	require.Nil(t, err)
267	header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil)
268	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64())
269	assert.Equal(t, forgerAddress, auctionEvents.NewCoordinator[0].ForgerAddress)
270	assert.Equal(t, forgerAddress, auctionEvents.NewCoordinator[0].WithdrawalAddress)
271	assert.Equal(t, URL, auctionEvents.NewCoordinator[0].CoordinatorURL)
272}
273
274func TestAuctionIsRegisteredCoordinatorTrue(t *testing.T) {
275	forgerAddress := governanceAddressConst
276
277	registered, err := auctionClient.AuctionIsRegisteredCoordinator(forgerAddress)
278	require.Nil(t, err)
279	assert.Equal(t, registered, true)
280}
281
282func TestAuctionUpdateCoordinatorInfo(t *testing.T) {
283	forgerAddress := governanceAddressConst
284
285	_, err := auctionClient.AuctionUpdateCoordinatorInfo(forgerAddress, forgerAddress, newURL)
286	require.Nil(t, err)
287	header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil)
288	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64())
289	assert.Equal(t, forgerAddress, auctionEvents.CoordinatorUpdated[0].ForgerAddress)
290	assert.Equal(t, forgerAddress, auctionEvents.CoordinatorUpdated[0].WithdrawalAddress)
291	assert.Equal(t, newURL, auctionEvents.CoordinatorUpdated[0].CoordinatorURL)
292}
293
294func TestAuctionBid(t *testing.T) {
295	currentSlot, err := auctionClient.AuctionGetCurrentSlotNumber()
296	require.Nil(t, err)
297	bidAmount := new(big.Int)
298	bidAmount.SetString("12000000000000000000", 10)
299	forgerAddress := governanceAddressConst
300	_, err = auctionClient.AuctionBid(currentSlot+4, bidAmount, forgerAddress)
301	require.Nil(t, err)
302	header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil)
303	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64())
304	assert.Equal(t, bidAmount, auctionEvents.NewBid[0].BidAmount)
305	assert.Equal(t, forgerAddress, auctionEvents.NewBid[0].CoordinatorForger)
306	assert.Equal(t, currentSlot+4, auctionEvents.NewBid[0].Slot)
307}
308
309func TestAuctionGetSlotNumber(t *testing.T) {
310	slotConst := 4
311	blockNum := int(BLOCKSPERSLOT)*slotConst + genesisBlock
312
313	slot, err := auctionClient.AuctionGetSlotNumber(int64(blockNum))
314	require.Nil(t, err)
315	assert.Equal(t, slot, big.NewInt(int64(slotConst)))
316}
317
318func TestAuctionCanForge(t *testing.T) {
319	slotConst := 4
320	blockNum := int(BLOCKSPERSLOT)*slotConst + genesisBlock
321
322	canForge, err := auctionClient.AuctionCanForge(governanceAddressConst, int64(blockNum))
323	require.Nil(t, err)
324	assert.Equal(t, canForge, true)
325}
326
327func TestAuctionMultiBid(t *testing.T) {
328	currentSlot, err := auctionClient.AuctionGetCurrentSlotNumber()
329	require.Nil(t, err)
330	slotSet := [6]bool{true, false, true, false, true, false}
331	maxBid := new(big.Int)
332	maxBid.SetString("15000000000000000000", 10)
333	minBid := new(big.Int)
334	minBid.SetString("11000000000000000000", 10)
335	budget := new(big.Int)
336	budget.SetString("45200000000000000000", 10)
337	forgerAddress := governanceAddressConst
338	_, err = auctionClient.AuctionMultiBid(currentSlot+4, currentSlot+10, slotSet, maxBid, minBid, budget, forgerAddress)
339	require.Nil(t, err)
340	header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil)
341	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64())
342	assert.Equal(t, forgerAddress, auctionEvents.NewBid[0].CoordinatorForger)
343	assert.Equal(t, currentSlot+4, auctionEvents.NewBid[0].Slot)
344	assert.Equal(t, forgerAddress, auctionEvents.NewBid[1].CoordinatorForger)
345	assert.Equal(t, currentSlot+6, auctionEvents.NewBid[1].Slot)
346	assert.Equal(t, forgerAddress, auctionEvents.NewBid[2].CoordinatorForger)
347	assert.Equal(t, currentSlot+8, auctionEvents.NewBid[2].Slot)
348	assert.Equal(t, forgerAddress, auctionEvents.NewBid[3].CoordinatorForger)
349	assert.Equal(t, currentSlot+10, auctionEvents.NewBid[3].Slot)
350}
351
352func TestAuctionGetClaimableHEZ2(t *testing.T) {
353	forgerAddress := governanceAddressConst
354	amount := new(big.Int)
355	amount.SetString("11000000000000000000", 10)
356
357	claimableHEZ, err := auctionClient.AuctionGetClaimableHEZ(forgerAddress)
358	require.Nil(t, err)
359	assert.Equal(t, claimableHEZ, amount)
360}
361
362func TestAuctionClaimHEZ(t *testing.T) {
363	amount := new(big.Int)
364	amount.SetString("11000000000000000000", 10)
365
366	_, err := auctionClient.AuctionClaimHEZ(governanceAddressConst)
367	require.Nil(t, err)
368	header, _ := auctionClient.client.client.HeaderByNumber(context.Background(), nil)
369	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(header.Number.Int64())
370	assert.Equal(t, amount, auctionEvents.HEZClaimed[0].Amount)
371	assert.Equal(t, governanceAddressConst, auctionEvents.HEZClaimed[0].Owner)
372}