arnaucube/hermez-node
1
0
Fork 0
mirror of https://github.com/arnaucube/hermez-node.git synced 2026-02-07 03:16:45 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #263 from hermeznetwork/feature/wrapped-in-struct

Browse Source 
Put api DBs into struct
This commit is contained in:
Eduard S
2020-11-06 15:05:53 +01:00
committed by GitHub
parent 4a29cafcb7 1112ded933
commit 220fd992c5
18 changed files with 172 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
api/account.go
View File

@@ -9,21 +9,21 @@ import (
"github.com/hermeznetwork/hermez-node/db/historydb" "github.com/hermeznetwork/hermez-node/db/historydb"
) )
func getAccount(c *gin.Context) { func (a *API) getAccount(c *gin.Context) {
// Get Addr // Get Addr
idx, err := parseParamIdx(c) idx, err := parseParamIdx(c)
if err != nil { if err != nil {
retBadReq(err, c) retBadReq(err, c)
return return
} }
apiAccount, err := h.GetAccountAPI(*idx) apiAccount, err := a.h.GetAccountAPI(*idx)
if err != nil { if err != nil {
retSQLErr(err, c) retSQLErr(err, c)
return return
} }
// Get balance from stateDB // Get balance from stateDB
account, err := s.GetAccount(*idx) account, err := a.s.GetAccount(*idx)
if err != nil { if err != nil {
retSQLErr(err, c) retSQLErr(err, c)
return return
@@ -34,7 +34,7 @@ func getAccount(c *gin.Context) {
c.JSON(http.StatusOK, apiAccount) c.JSON(http.StatusOK, apiAccount)
} }
func getAccounts(c *gin.Context) { func (a *API) getAccounts(c *gin.Context) {
// Account filters // Account filters
tokenIDs, addr, bjj, err := parseAccountFilters(c) tokenIDs, addr, bjj, err := parseAccountFilters(c)
if err != nil { if err != nil {
@@ -49,7 +49,7 @@ func getAccounts(c *gin.Context) {
} }
// Fetch Accounts from historyDB // Fetch Accounts from historyDB
apiAccounts, pagination, err := h.GetAccountsAPI(tokenIDs, addr, bjj, fromItem, limit, order) apiAccounts, pagination, err := a.h.GetAccountsAPI(tokenIDs, addr, bjj, fromItem, limit, order)
if err != nil { if err != nil {
retSQLErr(err, c) retSQLErr(err, c)
return return
@@ -62,7 +62,7 @@ func getAccounts(c *gin.Context) {
retSQLErr(err, c) retSQLErr(err, c)
return return
} }
account, err := s.GetAccount(*idx) account, err := a.s.GetAccount(*idx)
if err != nil { if err != nil {
retSQLErr(err, c) retSQLErr(err, c)
return return

8
api/accountcreationauths.go
View File

@@ -12,7 +12,7 @@ import (
"github.com/iden3/go-iden3-crypto/babyjub" "github.com/iden3/go-iden3-crypto/babyjub"
) )
func postAccountCreationAuth(c *gin.Context) { func (a *API) postAccountCreationAuth(c *gin.Context) {
// Parse body // Parse body
var apiAuth receivedAuth var apiAuth receivedAuth
if err := c.ShouldBindJSON(&apiAuth); err != nil { if err := c.ShouldBindJSON(&apiAuth); err != nil {
@@ -26,7 +26,7 @@ func postAccountCreationAuth(c *gin.Context) {
return return
} }
// Insert to DB // Insert to DB
if err := l2.AddAccountCreationAuth(commonAuth); err != nil { if err := a.l2.AddAccountCreationAuth(commonAuth); err != nil {
retSQLErr(err, c) retSQLErr(err, c)
return return
} }
@@ -34,7 +34,7 @@ func postAccountCreationAuth(c *gin.Context) {
c.Status(http.StatusOK) c.Status(http.StatusOK)
} }
func getAccountCreationAuth(c *gin.Context) { func (a *API) getAccountCreationAuth(c *gin.Context) {
// Get hezEthereumAddress // Get hezEthereumAddress
addr, err := parseParamHezEthAddr(c) addr, err := parseParamHezEthAddr(c)
if err != nil { if err != nil {
@@ -42,7 +42,7 @@ func getAccountCreationAuth(c *gin.Context) {
return return
} }
// Fetch auth from l2DB // Fetch auth from l2DB
auth, err := l2.GetAccountCreationAuthAPI(*addr) auth, err := a.l2.GetAccountCreationAuthAPI(*addr)
if err != nil { if err != nil {
retSQLErr(err, c) retSQLErr(err, c)
return return

91
api/api.go
View File

@@ -4,75 +4,90 @@ import (
"errors" "errors"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/hermeznetwork/hermez-node/common"
"github.com/hermeznetwork/hermez-node/db/historydb" "github.com/hermeznetwork/hermez-node/db/historydb"
"github.com/hermeznetwork/hermez-node/db/l2db" "github.com/hermeznetwork/hermez-node/db/l2db"
"github.com/hermeznetwork/hermez-node/db/statedb" "github.com/hermeznetwork/hermez-node/db/statedb"
) )
var h *historydb.HistoryDB // Status define status of the network
var cg *configAPI type Status struct {
var s *statedb.StateDB Network historydb.Network `json:"network"`
var l2 *l2db.L2DB Metrics historydb.Metrics `json:"metrics"`
Rollup common.RollupVariables `json:"rollup"`
Auction common.AuctionVariables `json:"auction"`
WithdrawalDelayer common.WDelayerVariables `json:"withdrawalDelayer"`
RecommendedFee common.RecommendedFee `json:"recommendedFee"`
}
// SetAPIEndpoints sets the endpoints and the appropriate handlers, but doesn't start the server // API serves HTTP requests to allow external interaction with the Hermez node
func SetAPIEndpoints( type API struct {
h *historydb.HistoryDB
cg *configAPI
s *statedb.StateDB
l2 *l2db.L2DB
status Status
}
// NewAPI sets the endpoints and the appropriate handlers, but doesn't start the server
func NewAPI(
coordinatorEndpoints, explorerEndpoints bool, coordinatorEndpoints, explorerEndpoints bool,
server *gin.Engine, server *gin.Engine,
hdb *historydb.HistoryDB, hdb *historydb.HistoryDB,
sdb *statedb.StateDB, sdb *statedb.StateDB,
l2db *l2db.L2DB, l2db *l2db.L2DB,
config *configAPI, config *configAPI,
) error { ) (*API, error) {
// Check input // Check input
// TODO: is stateDB only needed for explorer endpoints or for both? // TODO: is stateDB only needed for explorer endpoints or for both?
if coordinatorEndpoints && l2db == nil { if coordinatorEndpoints && l2db == nil {
return errors.New("cannot serve Coordinator endpoints without L2DB") return nil, errors.New("cannot serve Coordinator endpoints without L2DB")
} }
if explorerEndpoints && hdb == nil { if explorerEndpoints && hdb == nil {
return errors.New("cannot serve Explorer endpoints without HistoryDB") return nil, errors.New("cannot serve Explorer endpoints without HistoryDB")
} }
h = hdb a := &API{
cg = config h: hdb,
s = sdb cg: config,
l2 = l2db s: sdb,
l2: l2db,
}
// Add coordinator endpoints // Add coordinator endpoints
if coordinatorEndpoints { if coordinatorEndpoints {
// Account // Account
server.POST("/account-creation-authorization", postAccountCreationAuth) server.POST("/account-creation-authorization", a.postAccountCreationAuth)
server.GET("/account-creation-authorization/:hermezEthereumAddress", getAccountCreationAuth) server.GET("/account-creation-authorization/:hermezEthereumAddress", a.getAccountCreationAuth)
// Transaction // Transaction
server.POST("/transactions-pool", postPoolTx) server.POST("/transactions-pool", a.postPoolTx)
server.GET("/transactions-pool/:id", getPoolTx) server.GET("/transactions-pool/:id", a.getPoolTx)
} }
// Add explorer endpoints // Add explorer endpoints
if explorerEndpoints { if explorerEndpoints {
// Account // Account
server.GET("/accounts", getAccounts) server.GET("/accounts", a.getAccounts)
server.GET("/accounts/:accountIndex", getAccount) server.GET("/accounts/:accountIndex", a.getAccount)
server.GET("/exits", getExits) server.GET("/exits", a.getExits)
server.GET("/exits/:batchNum/:accountIndex", getExit) server.GET("/exits/:batchNum/:accountIndex", a.getExit)
// Transaction // Transaction
server.GET("/transactions-history", getHistoryTxs) server.GET("/transactions-history", a.getHistoryTxs)
server.GET("/transactions-history/:id", getHistoryTx) server.GET("/transactions-history/:id", a.getHistoryTx)
// Status // Status
server.GET("/batches", getBatches) server.GET("/batches", a.getBatches)
server.GET("/batches/:batchNum", getBatch) server.GET("/batches/:batchNum", a.getBatch)
server.GET("/full-batches/:batchNum", getFullBatch) server.GET("/full-batches/:batchNum", a.getFullBatch)
server.GET("/slots", getSlots) server.GET("/slots", a.getSlots)
server.GET("/slots/:slotNum", getSlot) server.GET("/slots/:slotNum", a.getSlot)
server.GET("/bids", getBids) server.GET("/bids", a.getBids)
server.GET("/next-forgers", getNextForgers) server.GET("/state", a.getState)
server.GET("/state", getState) server.GET("/config", a.getConfig)
server.GET("/config", getConfig) server.GET("/tokens", a.getTokens)
server.GET("/tokens", getTokens) server.GET("/tokens/:id", a.getToken)
server.GET("/tokens/:id", getToken) server.GET("/coordinators", a.getCoordinators)
server.GET("/recommendedFee", getRecommendedFee) server.GET("/coordinators/:bidderAddr", a.getCoordinator)
server.GET("/coordinators", getCoordinators)
server.GET("/coordinators/:bidderAddr", getCoordinator)
} }
return nil return a, nil
} }

40
api/api_test.go
View File

@@ -56,6 +56,7 @@ type testCommon struct {
var tc testCommon var tc testCommon
var config configAPI var config configAPI
var api *API
// TestMain initializes the API server, and fill HistoryDB and StateDB with fake data, // TestMain initializes the API server, and fill HistoryDB and StateDB with fake data,
// emulating the task of the synchronizer in order to have data to be returned // emulating the task of the synchronizer in order to have data to be returned
@@ -97,20 +98,21 @@ func TestMain(m *testing.M) {
config = getConfigTest() config = getConfigTest()
// API // API
api := gin.Default() apiGin := gin.Default()
if err := SetAPIEndpoints( api, err = NewAPI(
true, true,
true, true,
api, apiGin,
hdb, hdb,
sdb, sdb,
l2DB, l2DB,
&config, &config,
); err != nil { )
if err != nil {
panic(err) panic(err)
} }
// Start server // Start server
server := &http.Server{Addr: apiPort, Handler: api} server := &http.Server{Addr: apiPort, Handler: apiGin}
go func() { go func() {
if err := server.ListenAndServe(); err != nil && if err := server.ListenAndServe(); err != nil &&
err != http.ErrServerClosed { err != http.ErrServerClosed {
@@ -122,7 +124,7 @@ func TestMain(m *testing.M) {
// Gen blocks and add them to DB // Gen blocks and add them to DB
const nBlocks = 5 const nBlocks = 5
blocks := test.GenBlocks(1, nBlocks+1) blocks := test.GenBlocks(1, nBlocks+1)
err = h.AddBlocks(blocks) err = api.h.AddBlocks(blocks)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@@ -131,7 +133,7 @@ func TestMain(m *testing.M) {
// Gen tokens and add them to DB // Gen tokens and add them to DB
const nTokens = 10 const nTokens = 10
tokens, ethToken := test.GenTokens(nTokens, blocks) tokens, ethToken := test.GenTokens(nTokens, blocks)
err = h.AddTokens(tokens) err = api.h.AddTokens(tokens)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@@ -153,7 +155,7 @@ func TestMain(m *testing.M) {
now := time.Now().UTC() now := time.Now().UTC()
token.USD = &value token.USD = &value
token.USDUpdate = &now token.USDUpdate = &now
err = h.UpdateTokenValue(token.Symbol, value) err = api.h.UpdateTokenValue(token.Symbol, value)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@@ -163,7 +165,7 @@ func TestMain(m *testing.M) {
// Gen batches and add them to DB // Gen batches and add them to DB
const nBatches = 10 const nBatches = 10
batches := test.GenBatches(nBatches, blocks) batches := test.GenBatches(nBatches, blocks)
err = h.AddBatches(batches) err = api.h.AddBatches(batches)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@@ -174,12 +176,12 @@ func TestMain(m *testing.M) {
privK := babyjub.NewRandPrivKey() privK := babyjub.NewRandPrivKey()
usrBjj := privK.Public() usrBjj := privK.Public()
accs := test.GenAccounts(totalAccounts, userAccounts, tokens, &usrAddr, usrBjj, batches) accs := test.GenAccounts(totalAccounts, userAccounts, tokens, &usrAddr, usrBjj, batches)
err = h.AddAccounts(accs) err = api.h.AddAccounts(accs)
if err != nil { if err != nil {
panic(err) panic(err)
} }
for i := 0; i < len(accs); i++ { for i := 0; i < len(accs); i++ {
if _, err := s.CreateAccount(accs[i].Idx, &accs[i]); err != nil { if _, err := api.s.CreateAccount(accs[i].Idx, &accs[i]); err != nil {
panic(err) panic(err)
} }
} }
@@ -197,7 +199,7 @@ func TestMain(m *testing.M) {
// Gen exits and add them to DB // Gen exits and add them to DB
const totalExits = 40 const totalExits = 40
exits := test.GenExitTree(totalExits, batches, accs) exits := test.GenExitTree(totalExits, batches, accs)
err = h.AddExitTree(exits) err = api.h.AddExitTree(exits)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@@ -235,12 +237,12 @@ func TestMain(m *testing.M) {
l1 := genericTx.L1() l1 := genericTx.L1()
l2 := genericTx.L2() l2 := genericTx.L2()
if l1 != nil { if l1 != nil {
err = h.AddL1Txs([]common.L1Tx{*l1}) err = api.h.AddL1Txs([]common.L1Tx{*l1})
if err != nil { if err != nil {
panic(err) panic(err)
} }
} else if l2 != nil { } else if l2 != nil {
err = h.AddL2Txs([]common.L2Tx{*l2}) err = api.h.AddL2Txs([]common.L2Tx{*l2})
if err != nil { if err != nil {
panic(err) panic(err)
} }
@@ -252,13 +254,13 @@ func TestMain(m *testing.M) {
// Coordinators // Coordinators
const nCoords = 10 const nCoords = 10
coords := test.GenCoordinators(nCoords, blocks) coords := test.GenCoordinators(nCoords, blocks)
err = hdb.AddCoordinators(coords) err = api.h.AddCoordinators(coords)
if err != nil { if err != nil {
panic(err) panic(err)
} }
fromItem := uint(0) fromItem := uint(0)
limit := uint(99999) limit := uint(99999)
coordinators, _, err := hdb.GetCoordinatorsAPI(&fromItem, &limit, historydb.OrderAsc) coordinators, _, err := api.h.GetCoordinatorsAPI(&fromItem, &limit, historydb.OrderAsc)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@@ -266,7 +268,7 @@ func TestMain(m *testing.M) {
// Bids // Bids
const nBids = 20 const nBids = 20
bids := test.GenBids(nBids, blocks, coords) bids := test.GenBids(nBids, blocks, coords)
err = hdb.AddBids(bids) err = api.h.AddBids(bids)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@@ -278,7 +280,7 @@ func TestMain(m *testing.M) {
ClosedAuctionSlots: uint16(2), ClosedAuctionSlots: uint16(2),
OpenAuctionSlots: uint16(5), OpenAuctionSlots: uint16(5),
} }
err = hdb.AddAuctionVars(&auctionVars) err = api.h.AddAuctionVars(&auctionVars)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@@ -309,7 +311,7 @@ func TestMain(m *testing.M) {
auths: genTestAuths(test.GenAuths(5)), auths: genTestAuths(test.GenAuths(5)),
router: router, router: router,
bids: testBids, bids: testBids,
slots: genTestSlots(nSlots, lastBlockNum, testBids, auctionVars), slots: api.genTestSlots(nSlots, lastBlockNum, testBids, auctionVars),
auctionVars: auctionVars, auctionVars: auctionVars,
} }

14
api/batch.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/hermeznetwork/hermez-node/db/historydb" "github.com/hermeznetwork/hermez-node/db/historydb"
) )
func getBatches(c *gin.Context) { func (a *API) getBatches(c *gin.Context) {
// Get query parameters // Get query parameters
// minBatchNum // minBatchNum
minBatchNum, err := parseQueryUint("minBatchNum", nil, 0, maxUint32, c) minBatchNum, err := parseQueryUint("minBatchNum", nil, 0, maxUint32, c)
@@ -43,7 +43,7 @@ func getBatches(c *gin.Context) {
return return
} }
// Fetch batches from historyDB // Fetch batches from historyDB
batches, pagination, err := h.GetBatchesAPI( batches, pagination, err := a.h.GetBatchesAPI(
minBatchNum, maxBatchNum, slotNum, forgerAddr, fromItem, limit, order, minBatchNum, maxBatchNum, slotNum, forgerAddr, fromItem, limit, order,
) )
if err != nil { if err != nil {
@@ -62,7 +62,7 @@ func getBatches(c *gin.Context) {
}) })
} }
func getBatch(c *gin.Context) { func (a *API) getBatch(c *gin.Context) {
// Get batchNum // Get batchNum
batchNum, err := parseParamUint("batchNum", nil, 0, maxUint32, c) batchNum, err := parseParamUint("batchNum", nil, 0, maxUint32, c)
if err != nil { if err != nil {
@@ -74,7 +74,7 @@ func getBatch(c *gin.Context) {
return return
} }
// Fetch batch from historyDB // Fetch batch from historyDB
batch, err := h.GetBatchAPI(common.BatchNum(*batchNum)) batch, err := a.h.GetBatchAPI(common.BatchNum(*batchNum))
if err != nil { if err != nil {
retSQLErr(err, c) retSQLErr(err, c)
return return
@@ -88,7 +88,7 @@ type fullBatch struct {
Txs []historydb.TxAPI `json:"transactions"` Txs []historydb.TxAPI `json:"transactions"`
} }
func getFullBatch(c *gin.Context) { func (a *API) getFullBatch(c *gin.Context) {
// Get batchNum // Get batchNum
batchNum, err := parseParamUint("batchNum", nil, 0, maxUint32, c) batchNum, err := parseParamUint("batchNum", nil, 0, maxUint32, c)
if err != nil { if err != nil {
@@ -100,14 +100,14 @@ func getFullBatch(c *gin.Context) {
return return
} }
// Fetch batch from historyDB // Fetch batch from historyDB
batch, err := h.GetBatchAPI(common.BatchNum(*batchNum)) batch, err := a.h.GetBatchAPI(common.BatchNum(*batchNum))
if err != nil { if err != nil {
retSQLErr(err, c) retSQLErr(err, c)
return return
} }
// Fetch txs forged in the batch from historyDB // Fetch txs forged in the batch from historyDB
maxTxsPerBatch := uint(2048) //nolint:gomnd maxTxsPerBatch := uint(2048) //nolint:gomnd
txs, _, err := h.GetHistoryTxs( txs, _, err := a.h.GetHistoryTxs(
nil, nil, nil, nil, batchNum, nil, nil, &maxTxsPerBatch, historydb.OrderAsc, nil, nil, nil, nil, batchNum, nil, nil, &maxTxsPerBatch, historydb.OrderAsc,
) )
if err != nil { if err != nil {

4
api/bids.go
View File

@@ -9,7 +9,7 @@ import (
"github.com/hermeznetwork/hermez-node/db/historydb" "github.com/hermeznetwork/hermez-node/db/historydb"
) )
func getBids(c *gin.Context) { func (a *API) getBids(c *gin.Context) {
slotNum, bidderAddr, err := parseBidFilters(c) slotNum, bidderAddr, err := parseBidFilters(c)
if err != nil { if err != nil {
retBadReq(err, c) retBadReq(err, c)
@@ -26,7 +26,7 @@ func getBids(c *gin.Context) {
return return
} }
bids, pagination, err := h.GetBidsAPI( bids, pagination, err := a.h.GetBidsAPI(
slotNum, bidderAddr, fromItem, limit, order, slotNum, bidderAddr, fromItem, limit, order,
) )

4
api/config.go
View File

@@ -32,6 +32,6 @@ type configAPI struct {
WDelayerConstants common.WDelayerConstants `json:"withdrawalDelayer"` WDelayerConstants common.WDelayerConstants `json:"withdrawalDelayer"`
} }
func getConfig(c *gin.Context) { func (a *API) getConfig(c *gin.Context) {
c.JSON(http.StatusOK, cg) c.JSON(http.StatusOK, a.cg)
} }

2
api/config_test.go
View File

@@ -62,5 +62,5 @@ func TestGetConfig(t *testing.T) {
var configTest configAPI var configTest configAPI
assert.NoError(t, doGoodReq("GET", endpoint, nil, &configTest)) assert.NoError(t, doGoodReq("GET", endpoint, nil, &configTest))
assert.Equal(t, config, configTest) assert.Equal(t, config, configTest)
assert.Equal(t, cg, &configTest) assert.Equal(t, api.cg, &configTest)
} }

8
api/coordinator.go
View File

@@ -8,7 +8,7 @@ import (
"github.com/hermeznetwork/hermez-node/db/historydb" "github.com/hermeznetwork/hermez-node/db/historydb"
) )
func getCoordinator(c *gin.Context) { func (a *API) getCoordinator(c *gin.Context) {
// Get bidderAddr // Get bidderAddr
const name = "bidderAddr" const name = "bidderAddr"
bidderAddr, err := parseParamEthAddr(name, c) bidderAddr, err := parseParamEthAddr(name, c)
@@ -21,7 +21,7 @@ func getCoordinator(c *gin.Context) {
return return
} }
coordinator, err := h.GetCoordinatorAPI(*bidderAddr) coordinator, err := a.h.GetCoordinatorAPI(*bidderAddr)
if err != nil { if err != nil {
retSQLErr(err, c) retSQLErr(err, c)
return return
@@ -30,7 +30,7 @@ func getCoordinator(c *gin.Context) {
c.JSON(http.StatusOK, coordinator) c.JSON(http.StatusOK, coordinator)
} }
func getCoordinators(c *gin.Context) { func (a *API) getCoordinators(c *gin.Context) {
// Pagination // Pagination
fromItem, order, limit, err := parsePagination(c) fromItem, order, limit, err := parsePagination(c)
if err != nil { if err != nil {
@@ -39,7 +39,7 @@ func getCoordinators(c *gin.Context) {
} }
// Fetch coordinators from historyDB // Fetch coordinators from historyDB
coordinators, pagination, err := h.GetCoordinatorsAPI(fromItem, limit, order) coordinators, pagination, err := a.h.GetCoordinatorsAPI(fromItem, limit, order)
if err != nil { if err != nil {
retSQLErr(err, c) retSQLErr(err, c)
return return

8
api/exits.go
View File

@@ -8,7 +8,7 @@ import (
"github.com/hermeznetwork/hermez-node/db/historydb" "github.com/hermeznetwork/hermez-node/db/historydb"
) )
func getExits(c *gin.Context) { func (a *API) getExits(c *gin.Context) {
// Get query parameters // Get query parameters
// Account filters // Account filters
tokenID, addr, bjj, idx, err := parseExitFilters(c) tokenID, addr, bjj, idx, err := parseExitFilters(c)
@@ -36,7 +36,7 @@ func getExits(c *gin.Context) {
} }
// Fetch exits from historyDB // Fetch exits from historyDB
exits, pagination, err := h.GetExitsAPI( exits, pagination, err := a.h.GetExitsAPI(
addr, bjj, tokenID, idx, batchNum, onlyPendingWithdraws, fromItem, limit, order, addr, bjj, tokenID, idx, batchNum, onlyPendingWithdraws, fromItem, limit, order,
) )
if err != nil { if err != nil {
@@ -55,7 +55,7 @@ func getExits(c *gin.Context) {
}) })
} }
func getExit(c *gin.Context) { func (a *API) getExit(c *gin.Context) {
// Get batchNum and accountIndex // Get batchNum and accountIndex
batchNum, err := parseParamUint("batchNum", nil, 0, maxUint32, c) batchNum, err := parseParamUint("batchNum", nil, 0, maxUint32, c)
if err != nil { if err != nil {
@@ -68,7 +68,7 @@ func getExit(c *gin.Context) {
return return
} }
// Fetch tx from historyDB // Fetch tx from historyDB
exit, err := h.GetExitAPI(batchNum, idx) exit, err := a.h.GetExitAPI(batchNum, idx)
if err != nil { if err != nil {
retSQLErr(err, c) retSQLErr(err, c)
return return

12
api/handlers.go
View File

@@ -31,18 +31,6 @@ var (
ErrNillBidderAddr = errors.New("biderAddr can not be nil") ErrNillBidderAddr = errors.New("biderAddr can not be nil")
) )
func getNextForgers(c *gin.Context) {
}
func getState(c *gin.Context) {
}
func getRecommendedFee(c *gin.Context) {
}
func retSQLErr(err error, c *gin.Context) { func retSQLErr(err error, c *gin.Context) {
if err == sql.ErrNoRows { if err == sql.ErrNoRows {
c.JSON(http.StatusNotFound, errorMsg{ c.JSON(http.StatusNotFound, errorMsg{

62
api/slots.go
View File

@@ -24,23 +24,23 @@ type SlotAPI struct {
LastItem uint64 `json:"-"` LastItem uint64 `json:"-"`
} }
func getFirstLastBlock(slotNum int64) (int64, int64) { func (a *API) getFirstLastBlock(slotNum int64) (int64, int64) {
genesisBlock := cg.AuctionConstants.GenesisBlockNum genesisBlock := a.cg.AuctionConstants.GenesisBlockNum
blocksPerSlot := int64(cg.AuctionConstants.BlocksPerSlot) blocksPerSlot := int64(a.cg.AuctionConstants.BlocksPerSlot)
firstBlock := slotNum*blocksPerSlot + genesisBlock firstBlock := slotNum*blocksPerSlot + genesisBlock
lastBlock := (slotNum+1)*blocksPerSlot + genesisBlock - 1 lastBlock := (slotNum+1)*blocksPerSlot + genesisBlock - 1
return firstBlock, lastBlock return firstBlock, lastBlock
} }
func getCurrentSlot(currentBlock int64) int64 { func (a *API) getCurrentSlot(currentBlock int64) int64 {
genesisBlock := cg.AuctionConstants.GenesisBlockNum genesisBlock := a.cg.AuctionConstants.GenesisBlockNum
blocksPerSlot := int64(cg.AuctionConstants.BlocksPerSlot) blocksPerSlot := int64(a.cg.AuctionConstants.BlocksPerSlot)
currentSlot := (currentBlock - genesisBlock) / blocksPerSlot currentSlot := (currentBlock - genesisBlock) / blocksPerSlot
return currentSlot return currentSlot
} }
func isOpenAuction(currentBlock, slotNum int64, auctionVars common.AuctionVariables) bool { func (a *API) isOpenAuction(currentBlock, slotNum int64, auctionVars common.AuctionVariables) bool {
currentSlot := getCurrentSlot(currentBlock) currentSlot := a.getCurrentSlot(currentBlock)
closedAuctionSlots := currentSlot + int64(auctionVars.ClosedAuctionSlots) closedAuctionSlots := currentSlot + int64(auctionVars.ClosedAuctionSlots)
openAuctionSlots := int64(auctionVars.OpenAuctionSlots) openAuctionSlots := int64(auctionVars.OpenAuctionSlots)
if slotNum > closedAuctionSlots && slotNum <= (closedAuctionSlots+openAuctionSlots) { if slotNum > closedAuctionSlots && slotNum <= (closedAuctionSlots+openAuctionSlots) {
@@ -61,9 +61,9 @@ func getPagination(totalItems uint64, minSlotNum, maxSlotNum *int64) *db.Paginat
return pagination return pagination
} }
func newSlotAPI(slotNum, currentBlockNum int64, bid *historydb.BidAPI, auctionVars *common.AuctionVariables) SlotAPI { func (a *API) newSlotAPI(slotNum, currentBlockNum int64, bid *historydb.BidAPI, auctionVars *common.AuctionVariables) SlotAPI {
firstBlock, lastBlock := getFirstLastBlock(slotNum) firstBlock, lastBlock := a.getFirstLastBlock(slotNum)
openAuction := isOpenAuction(currentBlockNum, slotNum, *auctionVars) openAuction := a.isOpenAuction(currentBlockNum, slotNum, *auctionVars)
slot := SlotAPI{ slot := SlotAPI{
ItemID: uint64(slotNum), ItemID: uint64(slotNum),
SlotNum: slotNum, SlotNum: slotNum,
@@ -75,10 +75,10 @@ func newSlotAPI(slotNum, currentBlockNum int64, bid *historydb.BidAPI, auctionVa
return slot return slot
} }
func newSlotsAPIFromWinnerBids(fromItem *uint, order string, bids []historydb.BidAPI, currentBlockNum int64, auctionVars *common.AuctionVariables) (slots []SlotAPI) { func (a *API) newSlotsAPIFromWinnerBids(fromItem *uint, order string, bids []historydb.BidAPI, currentBlockNum int64, auctionVars *common.AuctionVariables) (slots []SlotAPI) {
for i := range bids { for i := range bids {
slotNum := bids[i].SlotNum slotNum := bids[i].SlotNum
slot := newSlotAPI(slotNum, currentBlockNum, &bids[i], auctionVars) slot := a.newSlotAPI(slotNum, currentBlockNum, &bids[i], auctionVars)
if order == historydb.OrderAsc { if order == historydb.OrderAsc {
if slot.ItemID >= uint64(*fromItem) { if slot.ItemID >= uint64(*fromItem) {
slots = append(slots, slot) slots = append(slots, slot)
@@ -92,8 +92,8 @@ func newSlotsAPIFromWinnerBids(fromItem *uint, order string, bids []historydb.Bi
return slots return slots
} }
func addEmptySlot(slots []SlotAPI, slotNum int64, currentBlockNum int64, auctionVars *common.AuctionVariables, fromItem *uint, order string) ([]SlotAPI, error) { func (a *API) addEmptySlot(slots []SlotAPI, slotNum int64, currentBlockNum int64, auctionVars *common.AuctionVariables, fromItem *uint, order string) ([]SlotAPI, error) {
emptySlot := newSlotAPI(slotNum, currentBlockNum, nil, auctionVars) emptySlot := a.newSlotAPI(slotNum, currentBlockNum, nil, auctionVars)
if order == historydb.OrderAsc { if order == historydb.OrderAsc {
if emptySlot.ItemID >= uint64(*fromItem) { if emptySlot.ItemID >= uint64(*fromItem) {
slots = append(slots, emptySlot) slots = append(slots, emptySlot)
@@ -106,25 +106,25 @@ func addEmptySlot(slots []SlotAPI, slotNum int64, currentBlockNum int64, auction
return slots, nil return slots, nil
} }
func getSlot(c *gin.Context) { func (a *API) getSlot(c *gin.Context) {
slotNumUint, err := parseParamUint("slotNum", nil, 0, maxUint32, c) slotNumUint, err := parseParamUint("slotNum", nil, 0, maxUint32, c)
if err != nil { if err != nil {
retBadReq(err, c) retBadReq(err, c)
return return
} }
currentBlock, err := h.GetLastBlock() currentBlock, err := a.h.GetLastBlock()
if err != nil { if err != nil {
retBadReq(err, c) retBadReq(err, c)
return return
} }
auctionVars, err := h.GetAuctionVars() auctionVars, err := a.h.GetAuctionVars()
if err != nil { if err != nil {
retBadReq(err, c) retBadReq(err, c)
return return
} }
slotNum := int64(*slotNumUint) slotNum := int64(*slotNumUint)
bid, err := h.GetBestBidAPI(&slotNum) bid, err := a.h.GetBestBidAPI(&slotNum)
if err != nil && err != sql.ErrNoRows { if err != nil && err != sql.ErrNoRows {
retSQLErr(err, c) retSQLErr(err, c)
return return
@@ -132,9 +132,9 @@ func getSlot(c *gin.Context) {
var slot SlotAPI var slot SlotAPI
if err == sql.ErrNoRows { if err == sql.ErrNoRows {
slot = newSlotAPI(slotNum, currentBlock.EthBlockNum, nil, auctionVars) slot = a.newSlotAPI(slotNum, currentBlock.EthBlockNum, nil, auctionVars)
} else { } else {
slot = newSlotAPI(bid.SlotNum, currentBlock.EthBlockNum, &bid, auctionVars) slot = a.newSlotAPI(bid.SlotNum, currentBlock.EthBlockNum, &bid, auctionVars)
} }
// JSON response // JSON response
@@ -193,7 +193,7 @@ func getLimitsWithAddr(minSlotNum, maxSlotNum *int64, fromItem, limit *uint, ord
return minLim, maxLim return minLim, maxLim
} }
func getSlots(c *gin.Context) { func (a *API) getSlots(c *gin.Context) {
var slots []SlotAPI var slots []SlotAPI
minSlotNumDflt := int64(0) minSlotNumDflt := int64(0)
@@ -211,12 +211,12 @@ func getSlots(c *gin.Context) {
return return
} }
currentBlock, err := h.GetLastBlock() currentBlock, err := a.h.GetLastBlock()
if err != nil { if err != nil {
retBadReq(err, c) retBadReq(err, c)
return return
} }
auctionVars, err := h.GetAuctionVars() auctionVars, err := a.h.GetAuctionVars()
if err != nil { if err != nil {
retBadReq(err, c) retBadReq(err, c)
return return
@@ -231,13 +231,13 @@ func getSlots(c *gin.Context) {
retBadReq(errors.New("It is necessary to add maxSlotNum filter"), c) retBadReq(errors.New("It is necessary to add maxSlotNum filter"), c)
return return
} else if *finishedAuction { } else if *finishedAuction {
currentBlock, err := h.GetLastBlock() currentBlock, err := a.h.GetLastBlock()
if err != nil { if err != nil {
retBadReq(err, c) retBadReq(err, c)
return return
} }
currentSlot := getCurrentSlot(currentBlock.EthBlockNum) currentSlot := a.getCurrentSlot(currentBlock.EthBlockNum)
auctionVars, err := h.GetAuctionVars() auctionVars, err := a.h.GetAuctionVars()
if err != nil { if err != nil {
retBadReq(err, c) retBadReq(err, c)
return return
@@ -267,7 +267,7 @@ func getSlots(c *gin.Context) {
if wonByEthereumAddress == nil { if wonByEthereumAddress == nil {
slotMinLim, slotMaxLim = getLimits(minSlotNum, maxSlotNum, fromItem, limit, order) slotMinLim, slotMaxLim = getLimits(minSlotNum, maxSlotNum, fromItem, limit, order)
// Get best bids in range maxSlotNum - minSlotNum // Get best bids in range maxSlotNum - minSlotNum
bids, _, err = h.GetBestBidsAPI(&slotMinLim, &slotMaxLim, wonByEthereumAddress, nil, order) bids, _, err = a.h.GetBestBidsAPI(&slotMinLim, &slotMaxLim, wonByEthereumAddress, nil, order)
if err != nil && err != sql.ErrNoRows { if err != nil && err != sql.ErrNoRows {
retSQLErr(err, c) retSQLErr(err, c)
return return
@@ -275,7 +275,7 @@ func getSlots(c *gin.Context) {
totalItems = uint64(*maxSlotNum) - uint64(*minSlotNum) + 1 totalItems = uint64(*maxSlotNum) - uint64(*minSlotNum) + 1
} else { } else {
slotMinLim, slotMaxLim = getLimitsWithAddr(minSlotNum, maxSlotNum, fromItem, limit, order) slotMinLim, slotMaxLim = getLimitsWithAddr(minSlotNum, maxSlotNum, fromItem, limit, order)
bids, pag, err = h.GetBestBidsAPI(&slotMinLim, &slotMaxLim, wonByEthereumAddress, limit, order) bids, pag, err = a.h.GetBestBidsAPI(&slotMinLim, &slotMaxLim, wonByEthereumAddress, limit, order)
if err != nil && err != sql.ErrNoRows { if err != nil && err != sql.ErrNoRows {
retSQLErr(err, c) retSQLErr(err, c)
return return
@@ -290,7 +290,7 @@ func getSlots(c *gin.Context) {
// Build the slot information with previous bids // Build the slot information with previous bids
var slotsBids []SlotAPI var slotsBids []SlotAPI
if len(bids) > 0 { if len(bids) > 0 {
slotsBids = newSlotsAPIFromWinnerBids(fromItem, order, bids, currentBlock.EthBlockNum, auctionVars) slotsBids = a.newSlotsAPIFromWinnerBids(fromItem, order, bids, currentBlock.EthBlockNum, auctionVars)
if err != nil { if err != nil {
retBadReq(err, c) retBadReq(err, c)
return return
@@ -318,7 +318,7 @@ func getSlots(c *gin.Context) {
} }
} }
if !found { if !found {
slots, err = addEmptySlot(slots, i, currentBlock.EthBlockNum, auctionVars, fromItem, order) slots, err = a.addEmptySlot(slots, i, currentBlock.EthBlockNum, auctionVars, fromItem, order)
if err != nil { if err != nil {
retBadReq(err, c) retBadReq(err, c)
return return

16
api/slots_test.go
View File

@@ -41,7 +41,7 @@ func (t testSlotsResponse) Len() int {
return len(t.Slots) return len(t.Slots)
} }
func genTestSlots(nSlots int, lastBlockNum int64, bids []testBid, auctionVars common.AuctionVariables) []testSlot { func (a *API) genTestSlots(nSlots int, lastBlockNum int64, bids []testBid, auctionVars common.AuctionVariables) []testSlot {
tSlots := []testSlot{} tSlots := []testSlot{}
bestBids := make(map[int64]testBid) bestBids := make(map[int64]testBid)
// It's assumed that bids for each slot will be received in increasing order // It's assumed that bids for each slot will be received in increasing order
@@ -51,12 +51,12 @@ func genTestSlots(nSlots int, lastBlockNum int64, bids []testBid, auctionVars co
for i := int64(0); i < int64(nSlots); i++ { for i := int64(0); i < int64(nSlots); i++ {
bid, ok := bestBids[i] bid, ok := bestBids[i]
firstBlock, lastBlock := getFirstLastBlock(int64(i)) firstBlock, lastBlock := a.getFirstLastBlock(int64(i))
tSlot := testSlot{ tSlot := testSlot{
SlotNum: int64(i), SlotNum: int64(i),
FirstBlock: firstBlock, FirstBlock: firstBlock,
LastBlock: lastBlock, LastBlock: lastBlock,
OpenAuction: isOpenAuction(lastBlockNum, int64(i), auctionVars), OpenAuction: a.isOpenAuction(lastBlockNum, int64(i), auctionVars),
} }
if ok { if ok {
tSlot.WinnerBid = &bid tSlot.WinnerBid = &bid
@@ -66,8 +66,8 @@ func genTestSlots(nSlots int, lastBlockNum int64, bids []testBid, auctionVars co
return tSlots return tSlots
} }
func getEmptyTestSlot(slotNum int64) testSlot { func (a *API) getEmptyTestSlot(slotNum int64) testSlot {
firstBlock, lastBlock := getFirstLastBlock(slotNum) firstBlock, lastBlock := a.getFirstLastBlock(slotNum)
slot := testSlot{ slot := testSlot{
SlotNum: slotNum, SlotNum: slotNum,
FirstBlock: firstBlock, FirstBlock: firstBlock,
@@ -102,7 +102,7 @@ func TestGetSlot(t *testing.T) {
nil, &fetchedSlot, nil, &fetchedSlot,
), ),
) )
emptySlot := getEmptyTestSlot(slotNum) emptySlot := api.getEmptyTestSlot(slotNum)
assertSlot(t, emptySlot, fetchedSlot) assertSlot(t, emptySlot, fetchedSlot)
// Invalid slotNum // Invalid slotNum
@@ -131,7 +131,7 @@ func TestGetSlots(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
allSlots := tc.slots allSlots := tc.slots
for i := tc.slots[len(tc.slots)-1].SlotNum; i < maxSlotNum; i++ { for i := tc.slots[len(tc.slots)-1].SlotNum; i < maxSlotNum; i++ {
emptySlot := getEmptyTestSlot(i + 1) emptySlot := api.getEmptyTestSlot(i + 1)
allSlots = append(allSlots, emptySlot) allSlots = append(allSlots, emptySlot)
} }
assertSlots(t, allSlots, fetchedSlots) assertSlots(t, allSlots, fetchedSlots)
@@ -185,7 +185,7 @@ func TestGetSlots(t *testing.T) {
err = doGoodReqPaginated(path, historydb.OrderAsc, &testSlotsResponse{}, appendIter) err = doGoodReqPaginated(path, historydb.OrderAsc, &testSlotsResponse{}, appendIter)
assert.NoError(t, err) assert.NoError(t, err)
currentSlot := getCurrentSlot(tc.blocks[len(tc.blocks)-1].EthBlockNum) currentSlot := api.getCurrentSlot(tc.blocks[len(tc.blocks)-1].EthBlockNum)
finishedAuctionSlots := []testSlot{} finishedAuctionSlots := []testSlot{}
for i := 0; i < len(tc.slots); i++ { for i := 0; i < len(tc.slots); i++ {
finishAuction := currentSlot + int64(tc.auctionVars.ClosedAuctionSlots) finishAuction := currentSlot + int64(tc.auctionVars.ClosedAuctionSlots)

15
api/state.go
View File

@@ -1,16 +1,11 @@
package api package api
import ( import (
"github.com/hermeznetwork/hermez-node/common" "net/http"
"github.com/hermeznetwork/hermez-node/db/historydb"
"github.com/gin-gonic/gin"
) )
// Status define status of the network func (a *API) getState(c *gin.Context) {
type Status struct { c.JSON(http.StatusOK, a.status)
Network historydb.Network `json:"network"`
Metrics historydb.Metrics `json:"metrics"`
Rollup common.RollupVariables `json:"rollup"`
Auction common.AuctionVariables `json:"auction"`
WithdrawalDelayer common.WDelayerVariables `json:"withdrawalDelayer"`
RecommendedFee common.RecommendedFee `json:"recommendedFee"`
} }

8
api/token.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/hermeznetwork/hermez-node/db/historydb" "github.com/hermeznetwork/hermez-node/db/historydb"
) )
func getToken(c *gin.Context) { func (a *API) getToken(c *gin.Context) {
// Get TokenID // Get TokenID
tokenIDUint, err := parseParamUint("id", nil, 0, maxUint32, c) tokenIDUint, err := parseParamUint("id", nil, 0, maxUint32, c)
if err != nil { if err != nil {
@@ -23,7 +23,7 @@ func getToken(c *gin.Context) {
} }
tokenID := common.TokenID(*tokenIDUint) tokenID := common.TokenID(*tokenIDUint)
// Fetch token from historyDB // Fetch token from historyDB
token, err := h.GetToken(tokenID) token, err := a.h.GetToken(tokenID)
if err != nil { if err != nil {
retSQLErr(err, c) retSQLErr(err, c)
return return
@@ -31,7 +31,7 @@ func getToken(c *gin.Context) {
c.JSON(http.StatusOK, token) c.JSON(http.StatusOK, token)
} }
func getTokens(c *gin.Context) { func (a *API) getTokens(c *gin.Context) {
// Account filters // Account filters
tokenIDs, symbols, name, err := parseTokenFilters(c) tokenIDs, symbols, name, err := parseTokenFilters(c)
if err != nil { if err != nil {
@@ -46,7 +46,7 @@ func getTokens(c *gin.Context) {
return return
} }
// Fetch exits from historyDB // Fetch exits from historyDB
tokens, pagination, err := h.GetTokens( tokens, pagination, err := a.h.GetTokens(
tokenIDs, symbols, name, fromItem, limit, order, tokenIDs, symbols, name, fromItem, limit, order,
) )
if err != nil { if err != nil {

8
api/txshistory.go
View File

@@ -8,7 +8,7 @@ import (
"github.com/hermeznetwork/hermez-node/db/historydb" "github.com/hermeznetwork/hermez-node/db/historydb"
) )
func getHistoryTxs(c *gin.Context) { func (a *API) getHistoryTxs(c *gin.Context) {
// Get query parameters // Get query parameters
tokenID, addr, bjj, idx, err := parseExitFilters(c) tokenID, addr, bjj, idx, err := parseExitFilters(c)
if err != nil { if err != nil {
@@ -35,7 +35,7 @@ func getHistoryTxs(c *gin.Context) {
} }
// Fetch txs from historyDB // Fetch txs from historyDB
txs, pagination, err := h.GetHistoryTxs( txs, pagination, err := a.h.GetHistoryTxs(
addr, bjj, tokenID, idx, batchNum, txType, fromItem, limit, order, addr, bjj, tokenID, idx, batchNum, txType, fromItem, limit, order,
) )
if err != nil { if err != nil {
@@ -54,7 +54,7 @@ func getHistoryTxs(c *gin.Context) {
}) })
} }
func getHistoryTx(c *gin.Context) { func (a *API) getHistoryTx(c *gin.Context) {
// Get TxID // Get TxID
txID, err := parseParamTxID(c) txID, err := parseParamTxID(c)
if err != nil { if err != nil {
@@ -62,7 +62,7 @@ func getHistoryTx(c *gin.Context) {
return return
} }
// Fetch tx from historyDB // Fetch tx from historyDB
tx, err := h.GetHistoryTx(txID) tx, err := a.h.GetHistoryTx(txID)
if err != nil { if err != nil {
retSQLErr(err, c) retSQLErr(err, c)
return return

14
api/txspool.go
View File

@@ -13,7 +13,7 @@ import (
"github.com/iden3/go-iden3-crypto/babyjub" "github.com/iden3/go-iden3-crypto/babyjub"
) )
func postPoolTx(c *gin.Context) { func (a *API) postPoolTx(c *gin.Context) {
// Parse body // Parse body
var receivedTx receivedPoolTx var receivedTx receivedPoolTx
if err := c.ShouldBindJSON(&receivedTx); err != nil { if err := c.ShouldBindJSON(&receivedTx); err != nil {
@@ -22,12 +22,12 @@ func postPoolTx(c *gin.Context) {
} }
// Transform from received to insert format and validate // Transform from received to insert format and validate
writeTx := receivedTx.toPoolL2TxWrite() writeTx := receivedTx.toPoolL2TxWrite()
if err := verifyPoolL2TxWrite(writeTx); err != nil { if err := a.verifyPoolL2TxWrite(writeTx); err != nil {
retBadReq(err, c) retBadReq(err, c)
return return
} }
// Insert to DB // Insert to DB
if err := l2.AddTx(writeTx); err != nil { if err := a.l2.AddTx(writeTx); err != nil {
retSQLErr(err, c) retSQLErr(err, c)
return return
} }
@@ -35,7 +35,7 @@ func postPoolTx(c *gin.Context) {
c.JSON(http.StatusOK, writeTx.TxID.String()) c.JSON(http.StatusOK, writeTx.TxID.String())
} }
func getPoolTx(c *gin.Context) { func (a *API) getPoolTx(c *gin.Context) {
// Get TxID // Get TxID
txID, err := parseParamTxID(c) txID, err := parseParamTxID(c)
if err != nil { if err != nil {
@@ -43,7 +43,7 @@ func getPoolTx(c *gin.Context) {
return return
} }
// Fetch tx from l2DB // Fetch tx from l2DB
tx, err := l2.GetTxAPI(txID) tx, err := a.l2.GetTxAPI(txID)
if err != nil { if err != nil {
retSQLErr(err, c) retSQLErr(err, c)
return return
@@ -102,7 +102,7 @@ func (tx *receivedPoolTx) toPoolL2TxWrite() *l2db.PoolL2TxWrite {
} }
} }
func verifyPoolL2TxWrite(txw *l2db.PoolL2TxWrite) error { func (a *API) verifyPoolL2TxWrite(txw *l2db.PoolL2TxWrite) error {
poolTx := common.PoolL2Tx{ poolTx := common.PoolL2Tx{
TxID: txw.TxID, TxID: txw.TxID,
FromIdx: txw.FromIdx, FromIdx: txw.FromIdx,
@@ -159,7 +159,7 @@ func verifyPoolL2TxWrite(txw *l2db.PoolL2TxWrite) error {
return err return err
} }
// Get public key // Get public key
account, err := s.GetAccount(poolTx.FromIdx) account, err := a.s.GetAccount(poolTx.FromIdx)
if err != nil { if err != nil {
return err return err
} }

18
common/fee_test.go
View File

@@ -9,15 +9,15 @@ import (
) )
func TestFeePercentage(t *testing.T) { func TestFeePercentage(t *testing.T) {
assert.InEpsilon(t, 2.68E-18, FeeSelector(1).Percentage(), 0.002) assert.InEpsilon(t, 2.68e-18, FeeSelector(1).Percentage(), 0.002)
assert.InEpsilon(t, 6.76E-14, FeeSelector(10).Percentage(), 0.002) assert.InEpsilon(t, 6.76e-14, FeeSelector(10).Percentage(), 0.002)
assert.InEpsilon(t, 3.91E-03, FeeSelector(32).Percentage(), 0.002) assert.InEpsilon(t, 3.91e-03, FeeSelector(32).Percentage(), 0.002)
assert.InEpsilon(t, 7.29E-03, FeeSelector(50).Percentage(), 0.002) assert.InEpsilon(t, 7.29e-03, FeeSelector(50).Percentage(), 0.002)
assert.InEpsilon(t, 4.12E-02, FeeSelector(100).Percentage(), 0.002) assert.InEpsilon(t, 4.12e-02, FeeSelector(100).Percentage(), 0.002)
assert.InEpsilon(t, 2.33E-01, FeeSelector(150).Percentage(), 0.002) assert.InEpsilon(t, 2.33e-01, FeeSelector(150).Percentage(), 0.002)
assert.InEpsilon(t, 1.00E+00, FeeSelector(192).Percentage(), 0.002) assert.InEpsilon(t, 1.00e+00, FeeSelector(192).Percentage(), 0.002)
assert.InEpsilon(t, 2.56E+02, FeeSelector(200).Percentage(), 0.002) assert.InEpsilon(t, 2.56e+02, FeeSelector(200).Percentage(), 0.002)
assert.InEpsilon(t, 2.88E+17, FeeSelector(250).Percentage(), 0.002) assert.InEpsilon(t, 2.88e+17, FeeSelector(250).Percentage(), 0.002)
} }
func TestCalcFeeAmount(t *testing.T) { func TestCalcFeeAmount(t *testing.T) {