hermez-node/api/state_test.go
api/state_test.goRaw
1package api
2
3import (
4 "math/big"
5 "testing"
6
7 "github.com/hermeznetwork/hermez-node/apitypes"
8 "github.com/hermeznetwork/hermez-node/common"
9 "github.com/hermeznetwork/hermez-node/db/historydb"
10 "github.com/stretchr/testify/assert"
11 "github.com/stretchr/testify/require"
12)
13
14type testStatus struct {
15 Network testNetwork `json:"network"`
16 Metrics historydb.Metrics `json:"metrics"`
17 Rollup historydb.RollupVariablesAPI `json:"rollup"`
18 Auction historydb.AuctionVariablesAPI `json:"auction"`
19 WithdrawalDelayer common.WDelayerVariables `json:"withdrawalDelayer"`
20 RecommendedFee common.RecommendedFee `json:"recommendedFee"`
21}
22
23type testNetwork struct {
24 LastEthBlock int64 `json:"lastEthereumBlock"`
25 LastSyncBlock int64 `json:"lastSynchedBlock"`
26 LastBatch testBatch `json:"lastBatch"`
27 CurrentSlot int64 `json:"currentSlot"`
28 NextForgers []NextForger `json:"nextForgers"`
29}
30
31func TestSetRollupVariables(t *testing.T) {
32 rollupVars := &common.RollupVariables{}
33 assertEqualRollupVariables(t, *rollupVars, api.status.Rollup, true)
34 api.SetRollupVariables(tc.rollupVars)
35 assertEqualRollupVariables(t, tc.rollupVars, api.status.Rollup, true)
36}
37
38func assertEqualRollupVariables(t *testing.T, rollupVariables common.RollupVariables, apiVariables historydb.RollupVariablesAPI, checkBuckets bool) {
39 assert.Equal(t, apitypes.NewBigIntStr(rollupVariables.FeeAddToken), apiVariables.FeeAddToken)
40 assert.Equal(t, rollupVariables.ForgeL1L2BatchTimeout, apiVariables.ForgeL1L2BatchTimeout)
41 assert.Equal(t, rollupVariables.WithdrawalDelay, apiVariables.WithdrawalDelay)
42 assert.Equal(t, rollupVariables.SafeMode, apiVariables.SafeMode)
43 if checkBuckets {
44 for i, bucket := range rollupVariables.Buckets {
45 assert.Equal(t, apitypes.NewBigIntStr(bucket.BlockWithdrawalRate), apiVariables.Buckets[i].BlockWithdrawalRate)
46 assert.Equal(t, apitypes.NewBigIntStr(bucket.CeilUSD), apiVariables.Buckets[i].CeilUSD)
47 assert.Equal(t, apitypes.NewBigIntStr(bucket.MaxWithdrawals), apiVariables.Buckets[i].MaxWithdrawals)
48 assert.Equal(t, apitypes.NewBigIntStr(bucket.Withdrawals), apiVariables.Buckets[i].Withdrawals)
49 }
50 }
51}
52
53func TestSetWDelayerVariables(t *testing.T) {
54 wdelayerVars := &common.WDelayerVariables{}
55 assert.Equal(t, *wdelayerVars, api.status.WithdrawalDelayer)
56 api.SetWDelayerVariables(tc.wdelayerVars)
57 assert.Equal(t, tc.wdelayerVars, api.status.WithdrawalDelayer)
58}
59
60func TestSetAuctionVariables(t *testing.T) {
61 auctionVars := &common.AuctionVariables{}
62 assertEqualAuctionVariables(t, *auctionVars, api.status.Auction)
63 api.SetAuctionVariables(tc.auctionVars)
64 assertEqualAuctionVariables(t, tc.auctionVars, api.status.Auction)
65}
66
67func assertEqualAuctionVariables(t *testing.T, auctionVariables common.AuctionVariables, apiVariables historydb.AuctionVariablesAPI) {
68 assert.Equal(t, auctionVariables.EthBlockNum, apiVariables.EthBlockNum)
69 assert.Equal(t, auctionVariables.DonationAddress, apiVariables.DonationAddress)
70 assert.Equal(t, auctionVariables.BootCoordinator, apiVariables.BootCoordinator)
71 assert.Equal(t, auctionVariables.BootCoordinatorURL, apiVariables.BootCoordinatorURL)
72 assert.Equal(t, auctionVariables.DefaultSlotSetBidSlotNum, apiVariables.DefaultSlotSetBidSlotNum)
73 assert.Equal(t, auctionVariables.ClosedAuctionSlots, apiVariables.ClosedAuctionSlots)
74 assert.Equal(t, auctionVariables.OpenAuctionSlots, apiVariables.OpenAuctionSlots)
75 assert.Equal(t, auctionVariables.Outbidding, apiVariables.Outbidding)
76 assert.Equal(t, auctionVariables.SlotDeadline, apiVariables.SlotDeadline)
77
78 for i, slot := range auctionVariables.DefaultSlotSetBid {
79 assert.Equal(t, apitypes.NewBigIntStr(slot), apiVariables.DefaultSlotSetBid[i])
80 }
81
82 for i, ratio := range auctionVariables.AllocationRatio {
83 assert.Equal(t, ratio, apiVariables.AllocationRatio[i])
84 }
85}
86
87func TestUpdateNetworkInfo(t *testing.T) {
88 status := &Network{}
89 assert.Equal(t, status.LastSyncBlock, api.status.Network.LastSyncBlock)
90 assert.Equal(t, status.LastBatch, api.status.Network.LastBatch)
91 assert.Equal(t, status.CurrentSlot, api.status.Network.CurrentSlot)
92 assert.Equal(t, status.NextForgers, api.status.Network.NextForgers)
93 lastBlock := tc.blocks[3]
94 lastBatchNum := common.BatchNum(3)
95 currentSlotNum := int64(1)
96
97 // Generate some bucket_update data
98 bucketUpdates := []common.BucketUpdate{
99 {
100 EthBlockNum: 4,
101 NumBucket: 0,
102 BlockStamp: 4,
103 Withdrawals: big.NewInt(123),
104 },
105 {
106 EthBlockNum: 5,
107 NumBucket: 2,
108 BlockStamp: 5,
109 Withdrawals: big.NewInt(42),
110 },
111 {
112 EthBlockNum: 5,
113 NumBucket: 2, // Repeated bucket
114 BlockStamp: 5,
115 Withdrawals: big.NewInt(43),
116 },
117 }
118 err := api.h.AddBucketUpdatesTest(api.h.DB(), bucketUpdates)
119 require.NoError(t, err)
120
121 err = api.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
122 assert.NoError(t, err)
123 assert.Equal(t, lastBlock.Num, api.status.Network.LastSyncBlock)
124 assert.Equal(t, lastBatchNum, api.status.Network.LastBatch.BatchNum)
125 assert.Equal(t, currentSlotNum, api.status.Network.CurrentSlot)
126 assert.Equal(t, int(api.status.Auction.ClosedAuctionSlots)+1, len(api.status.Network.NextForgers))
127 assert.Equal(t, api.status.Rollup.Buckets[0].Withdrawals, apitypes.NewBigIntStr(big.NewInt(123)))
128 assert.Equal(t, api.status.Rollup.Buckets[2].Withdrawals, apitypes.NewBigIntStr(big.NewInt(43)))
129}
130
131func TestUpdateMetrics(t *testing.T) {
132 // Update Metrics needs api.status.Network.LastBatch.BatchNum to be updated
133 lastBlock := tc.blocks[3]
134 lastBatchNum := common.BatchNum(3)
135 currentSlotNum := int64(1)
136 err := api.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
137 assert.NoError(t, err)
138
139 err = api.UpdateMetrics()
140 assert.NoError(t, err)
141 assert.Greater(t, api.status.Metrics.TransactionsPerBatch, float64(0))
142 assert.Greater(t, api.status.Metrics.BatchFrequency, float64(0))
143 assert.Greater(t, api.status.Metrics.TransactionsPerSecond, float64(0))
144 assert.Greater(t, api.status.Metrics.TotalAccounts, int64(0))
145 assert.Greater(t, api.status.Metrics.TotalBJJs, int64(0))
146 assert.Greater(t, api.status.Metrics.AvgTransactionFee, float64(0))
147}
148
149func TestUpdateRecommendedFee(t *testing.T) {
150 err := api.UpdateRecommendedFee()
151 assert.NoError(t, err)
152 var minFeeUSD float64
153 if api.l2 != nil {
154 minFeeUSD = api.l2.MinFeeUSD()
155 }
156 assert.Greater(t, api.status.RecommendedFee.ExistingAccount, minFeeUSD)
157 assert.Equal(t, api.status.RecommendedFee.CreatesAccount,
158 api.status.RecommendedFee.ExistingAccount*createAccountExtraFeePercentage)
159 assert.Equal(t, api.status.RecommendedFee.CreatesAccountAndRegister,
160 api.status.RecommendedFee.ExistingAccount*createAccountInternalExtraFeePercentage)
161}
162
163func TestGetState(t *testing.T) {
164 lastBlock := tc.blocks[3]
165 lastBatchNum := common.BatchNum(3)
166 currentSlotNum := int64(1)
167 api.SetRollupVariables(tc.rollupVars)
168 api.SetWDelayerVariables(tc.wdelayerVars)
169 api.SetAuctionVariables(tc.auctionVars)
170 err := api.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
171 assert.NoError(t, err)
172 err = api.UpdateMetrics()
173 assert.NoError(t, err)
174 err = api.UpdateRecommendedFee()
175 assert.NoError(t, err)
176
177 endpoint := apiURL + "state"
178 var status testStatus
179
180 assert.NoError(t, doGoodReq("GET", endpoint, nil, &status))
181
182 // SC vars
183 // UpdateNetworkInfo will overwrite buckets withdrawal values
184 // So they won't be checked here, they are checked at
185 // TestUpdateNetworkInfo
186 assertEqualRollupVariables(t, tc.rollupVars, status.Rollup, false)
187 assertEqualAuctionVariables(t, tc.auctionVars, status.Auction)
188 assert.Equal(t, tc.wdelayerVars, status.WithdrawalDelayer)
189 // Network
190 assert.Equal(t, lastBlock.Num, status.Network.LastEthBlock)
191 assert.Equal(t, lastBlock.Num, status.Network.LastSyncBlock)
192 // TODO: assert all the batch, not just the batch num
193 assert.Equal(t, lastBatchNum, status.Network.LastBatch.BatchNum)
194 assert.Equal(t, currentSlotNum, status.Network.CurrentSlot)
195 assertNextForgers(t, tc.nextForgers, status.Network.NextForgers)
196 // Metrics
197 // TODO: perform real asserts (not just greater than 0)
198 assert.Greater(t, status.Metrics.TransactionsPerBatch, float64(0))
199 assert.Greater(t, status.Metrics.BatchFrequency, float64(0))
200 assert.Greater(t, status.Metrics.TransactionsPerSecond, float64(0))
201 assert.Greater(t, status.Metrics.TotalAccounts, int64(0))
202 assert.Greater(t, status.Metrics.TotalBJJs, int64(0))
203 assert.Greater(t, status.Metrics.AvgTransactionFee, float64(0))
204 // Recommended fee
205 // TODO: perform real asserts (not just greater than 0)
206 assert.Greater(t, status.RecommendedFee.ExistingAccount, float64(0))
207 assert.Equal(t, status.RecommendedFee.CreatesAccount,
208 status.RecommendedFee.ExistingAccount*createAccountExtraFeePercentage)
209 assert.Equal(t, status.RecommendedFee.CreatesAccountAndRegister,
210 status.RecommendedFee.ExistingAccount*createAccountInternalExtraFeePercentage)
211}
212
213func assertNextForgers(t *testing.T, expected, actual []NextForger) {
214 assert.Equal(t, len(expected), len(actual))
215 for i := range expected {
216 // ignore timestamps and other metadata
217 actual[i].Period.FromTimestamp = expected[i].Period.FromTimestamp
218 actual[i].Period.ToTimestamp = expected[i].Period.ToTimestamp
219 actual[i].Coordinator.ItemID = expected[i].Coordinator.ItemID
220 actual[i].Coordinator.EthBlockNum = expected[i].Coordinator.EthBlockNum
221 assert.Equal(t, expected[i], actual[i])
222 }
223}