mirror of
https://github.com/arnaucube/hermez-node.git
synced 2026-02-07 03:16:45 +01:00
Merge pull request #212 from hermeznetwork/feature/ethclient-simplify
Simplify eth code
This commit is contained in:
laisolizq
@@ -10,6 +10,7 @@ import (
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/ethereum/go-ethereum"
|
||||
ethCommon "github.com/ethereum/go-ethereum/common"
|
||||
"github.com/ethereum/go-ethereum/core/types"
|
||||
"github.com/hermeznetwork/hermez-node/common"
|
||||
@@ -225,7 +226,9 @@ type ClientSetup struct {
|
||||
VerifyProof bool
|
||||
}
|
||||
|
||||
// NewClientSetupExample returns a ClientSetup example with hardcoded realistic values.
|
||||
// NewClientSetupExample returns a ClientSetup example with hardcoded realistic
|
||||
// values. With this setup, the rollup genesis will be block 1, and block 0
|
||||
// and 1 will be premined.
|
||||
//nolint:gomnd
|
||||
func NewClientSetupExample() *ClientSetup {
|
||||
// rfield, ok := new(big.Int).SetString("21888242871839275222246405745257275088548364400416034343698204186575808495617", 10)
|
||||
@@ -259,7 +262,7 @@ func NewClientSetupExample() *ClientSetup {
|
||||
auctionConstants := ð.AuctionConstants{
|
||||
BlocksPerSlot: 40,
|
||||
InitialMinimalBidding: initialMinimalBidding,
|
||||
GenesisBlockNum: 0,
|
||||
GenesisBlockNum: 1,
|
||||
GovernanceAddress: governanceAddress,
|
||||
TokenHEZ: tokenHEZ,
|
||||
HermezRollup: ethCommon.HexToAddress("0x474B6e29852257491cf283EfB1A9C61eBFe48369"),
|
||||
@@ -296,6 +299,11 @@ type Timer interface {
|
||||
// blockHash ethCommon.Hash
|
||||
// }
|
||||
|
||||
type batch struct {
|
||||
ForgeBatchArgs eth.RollupForgeBatchArgs
|
||||
Sender ethCommon.Address
|
||||
}
|
||||
|
||||
// Client implements the eth.ClientInterface interface, allowing to manipulate the
|
||||
// values for testing, working with deterministic results.
|
||||
type Client struct {
|
||||
@@ -311,8 +319,8 @@ type Client struct {
|
||||
timer Timer
|
||||
hasher hasher
|
||||
|
||||
forgeBatchArgsPending map[ethCommon.Hash]*eth.RollupForgeBatchArgs
|
||||
forgeBatchArgs map[ethCommon.Hash]*eth.RollupForgeBatchArgs
|
||||
forgeBatchArgsPending map[ethCommon.Hash]*batch
|
||||
forgeBatchArgs map[ethCommon.Hash]*batch
|
||||
}
|
||||
|
||||
// NewClient returns a new test Client that implements the eth.IClient
|
||||
@@ -326,7 +334,7 @@ func NewClient(l bool, timer Timer, addr *ethCommon.Address, setup *ClientSetup)
|
||||
mapL1TxQueue := make(map[int64]*eth.QueueStruct)
|
||||
mapL1TxQueue[0] = eth.NewQueueStruct()
|
||||
mapL1TxQueue[1] = eth.NewQueueStruct()
|
||||
blockCurrent := Block{
|
||||
blockCurrent := &Block{
|
||||
Rollup: &RollupBlock{
|
||||
State: eth.RollupState{
|
||||
StateRoot: big.NewInt(0),
|
||||
@@ -367,11 +375,11 @@ func NewClient(l bool, timer Timer, addr *ethCommon.Address, setup *ClientSetup)
|
||||
}
|
||||
blockCurrent.Rollup.Eth = blockCurrent.Eth
|
||||
blockCurrent.Auction.Eth = blockCurrent.Eth
|
||||
blocks[blockNum] = &blockCurrent
|
||||
blocks[blockNum] = blockCurrent
|
||||
blockNext := blockCurrent.Next()
|
||||
blocks[blockNum+1] = blockNext
|
||||
|
||||
return &Client{
|
||||
c := Client{
|
||||
rw: &sync.RWMutex{},
|
||||
log: l,
|
||||
addr: addr,
|
||||
@@ -380,9 +388,17 @@ func NewClient(l bool, timer Timer, addr *ethCommon.Address, setup *ClientSetup)
|
||||
blocks: blocks,
|
||||
timer: timer,
|
||||
hasher: hasher,
|
||||
forgeBatchArgsPending: make(map[ethCommon.Hash]*eth.RollupForgeBatchArgs),
|
||||
forgeBatchArgs: make(map[ethCommon.Hash]*eth.RollupForgeBatchArgs),
|
||||
forgeBatchArgsPending: make(map[ethCommon.Hash]*batch),
|
||||
forgeBatchArgs: make(map[ethCommon.Hash]*batch),
|
||||
blockNum: blockNum,
|
||||
maxBlockNum: blockNum,
|
||||
}
|
||||
|
||||
for i := int64(1); i < setup.AuctionConstants.GenesisBlockNum+1; i++ {
|
||||
c.CtlMineBlock()
|
||||
}
|
||||
|
||||
return &c
|
||||
}
|
||||
|
||||
//
|
||||
@@ -452,7 +468,7 @@ func (c *Client) CtlMineBlock() {
|
||||
for ethTxHash, forgeBatchArgs := range c.forgeBatchArgsPending {
|
||||
c.forgeBatchArgs[ethTxHash] = forgeBatchArgs
|
||||
}
|
||||
c.forgeBatchArgsPending = make(map[ethCommon.Hash]*eth.RollupForgeBatchArgs)
|
||||
c.forgeBatchArgsPending = make(map[ethCommon.Hash]*batch)
|
||||
|
||||
blockNext := blockCurrent.Next()
|
||||
c.blocks[c.blockNum+1] = blockNext
|
||||
@@ -552,10 +568,10 @@ func (c *Client) EthBlockByNumber(ctx context.Context, blockNum int64) (*common.
|
||||
c.rw.RLock()
|
||||
defer c.rw.RUnlock()
|
||||
|
||||
block, ok := c.blocks[blockNum]
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("block not found")
|
||||
if blockNum > c.blockNum {
|
||||
return nil, ethereum.NotFound
|
||||
}
|
||||
block := c.blocks[blockNum]
|
||||
return &common.Block{
|
||||
EthBlockNum: blockNum,
|
||||
Timestamp: time.Unix(block.Eth.Time, 0),
|
||||
@@ -579,9 +595,54 @@ var errTODO = fmt.Errorf("TODO: Not implemented yet")
|
||||
//
|
||||
|
||||
// CtlAddL1TxUser adds an L1TxUser to the L1UserTxs queue of the Rollup
|
||||
func (c *Client) CtlAddL1TxUser(l1Tx *common.L1Tx) {
|
||||
// func (c *Client) CtlAddL1TxUser(l1Tx *common.L1Tx) {
|
||||
// c.rw.Lock()
|
||||
// defer c.rw.Unlock()
|
||||
//
|
||||
// nextBlock := c.nextBlock()
|
||||
// r := nextBlock.Rollup
|
||||
// queue := r.State.MapL1TxQueue[r.State.LastToForgeL1TxsNum]
|
||||
// if len(queue.L1TxQueue) >= eth.RollupConstMaxL1UserTx {
|
||||
// r.State.LastToForgeL1TxsNum++
|
||||
// r.State.MapL1TxQueue[r.State.LastToForgeL1TxsNum] = eth.NewQueueStruct()
|
||||
// queue = r.State.MapL1TxQueue[r.State.LastToForgeL1TxsNum]
|
||||
// }
|
||||
// if int64(l1Tx.FromIdx) > r.State.CurrentIdx {
|
||||
// panic("l1Tx.FromIdx > r.State.CurrentIdx")
|
||||
// }
|
||||
// if int(l1Tx.TokenID)+1 > len(r.State.TokenList) {
|
||||
// panic("l1Tx.TokenID + 1 > len(r.State.TokenList)")
|
||||
// }
|
||||
// queue.L1TxQueue = append(queue.L1TxQueue, *l1Tx)
|
||||
// r.Events.L1UserTx = append(r.Events.L1UserTx, eth.RollupEventL1UserTx{
|
||||
// L1Tx: *l1Tx,
|
||||
// ToForgeL1TxsNum: r.State.LastToForgeL1TxsNum,
|
||||
// Position: len(queue.L1TxQueue) - 1,
|
||||
// })
|
||||
// }
|
||||
|
||||
// RollupL1UserTxERC20ETH sends an L1UserTx to the Rollup.
|
||||
func (c *Client) RollupL1UserTxERC20ETH(
|
||||
fromBJJ *babyjub.PublicKey,
|
||||
fromIdx int64,
|
||||
loadAmount *big.Int,
|
||||
amount *big.Int,
|
||||
tokenID uint32,
|
||||
toIdx int64,
|
||||
) (tx *types.Transaction, err error) {
|
||||
c.rw.Lock()
|
||||
defer c.rw.Unlock()
|
||||
cpy := c.nextBlock().copy()
|
||||
defer func() { c.revertIfErr(err, cpy) }()
|
||||
|
||||
_, err = common.NewFloat16(amount)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
_, err = common.NewFloat16(loadAmount)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
nextBlock := c.nextBlock()
|
||||
r := nextBlock.Rollup
|
||||
@@ -591,24 +652,34 @@ func (c *Client) CtlAddL1TxUser(l1Tx *common.L1Tx) {
|
||||
r.State.MapL1TxQueue[r.State.LastToForgeL1TxsNum] = eth.NewQueueStruct()
|
||||
queue = r.State.MapL1TxQueue[r.State.LastToForgeL1TxsNum]
|
||||
}
|
||||
if int64(l1Tx.FromIdx) > r.State.CurrentIdx {
|
||||
if fromIdx > r.State.CurrentIdx {
|
||||
panic("l1Tx.FromIdx > r.State.CurrentIdx")
|
||||
}
|
||||
if int(l1Tx.TokenID)+1 > len(r.State.TokenList) {
|
||||
if int(tokenID)+1 > len(r.State.TokenList) {
|
||||
panic("l1Tx.TokenID + 1 > len(r.State.TokenList)")
|
||||
}
|
||||
toForgeL1TxsNum := r.State.LastToForgeL1TxsNum
|
||||
l1Tx, err := common.NewL1Tx(&common.L1Tx{
|
||||
FromIdx: common.Idx(fromIdx),
|
||||
FromEthAddr: *c.addr,
|
||||
FromBJJ: fromBJJ,
|
||||
Amount: amount,
|
||||
LoadAmount: loadAmount,
|
||||
TokenID: common.TokenID(tokenID),
|
||||
ToIdx: common.Idx(toIdx),
|
||||
ToForgeL1TxsNum: &toForgeL1TxsNum,
|
||||
Position: len(queue.L1TxQueue) - 1,
|
||||
UserOrigin: true,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
queue.L1TxQueue = append(queue.L1TxQueue, *l1Tx)
|
||||
r.Events.L1UserTx = append(r.Events.L1UserTx, eth.RollupEventL1UserTx{
|
||||
L1UserTx: *l1Tx,
|
||||
ToForgeL1TxsNum: r.State.LastToForgeL1TxsNum,
|
||||
Position: len(queue.L1TxQueue) - 1,
|
||||
L1UserTx: *l1Tx,
|
||||
})
|
||||
}
|
||||
|
||||
// RollupL1UserTxERC20ETH is the interface to call the smart contract function
|
||||
func (c *Client) RollupL1UserTxERC20ETH(fromBJJ *babyjub.PublicKey, fromIdx int64, loadAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64) (*types.Transaction, error) {
|
||||
log.Error("TODO")
|
||||
return nil, errTODO
|
||||
return r.addTransaction(newTransaction("l1UserTxERC20ETH", l1Tx)), nil
|
||||
}
|
||||
|
||||
// RollupL1UserTxERC777 is the interface to call the smart contract function
|
||||
@@ -710,7 +781,7 @@ func (c *Client) addBatch(args *eth.RollupForgeBatchArgs) (*types.Transaction, e
|
||||
}
|
||||
}
|
||||
ethTx := r.addTransaction(newTransaction("forgebatch", args))
|
||||
c.forgeBatchArgsPending[ethTx.Hash()] = args
|
||||
c.forgeBatchArgsPending[ethTx.Hash()] = &batch{*args, *c.addr}
|
||||
r.Events.ForgeBatch = append(r.Events.ForgeBatch, eth.RollupEventForgeBatch{
|
||||
BatchNum: int64(len(r.State.ExitRoots)),
|
||||
EthTxHash: ethTx.Hash(),
|
||||
@@ -820,15 +891,15 @@ func (c *Client) RollupEventsByBlock(blockNum int64) (*eth.RollupEvents, *ethCom
|
||||
}
|
||||
|
||||
// RollupForgeBatchArgs returns the arguments used in a ForgeBatch call in the Rollup Smart Contract in the given transaction
|
||||
func (c *Client) RollupForgeBatchArgs(ethTxHash ethCommon.Hash) (*eth.RollupForgeBatchArgs, error) {
|
||||
func (c *Client) RollupForgeBatchArgs(ethTxHash ethCommon.Hash) (*eth.RollupForgeBatchArgs, *ethCommon.Address, error) {
|
||||
c.rw.RLock()
|
||||
defer c.rw.RUnlock()
|
||||
|
||||
forgeBatchArgs, ok := c.forgeBatchArgs[ethTxHash]
|
||||
batch, ok := c.forgeBatchArgs[ethTxHash]
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("transaction not found")
|
||||
return nil, nil, fmt.Errorf("transaction not found")
|
||||
}
|
||||
return forgeBatchArgs, nil
|
||||
return &batch.ForgeBatchArgs, &batch.Sender, nil
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
@@ -42,21 +42,21 @@ func TestClientEth(t *testing.T) {
|
||||
c := NewClient(true, &timer, ðCommon.Address{}, clientSetup)
|
||||
blockNum, err := c.EthCurrentBlock()
|
||||
require.Nil(t, err)
|
||||
assert.Equal(t, int64(0), blockNum)
|
||||
assert.Equal(t, int64(1), blockNum)
|
||||
|
||||
block, err := c.EthBlockByNumber(context.TODO(), 0)
|
||||
require.Nil(t, err)
|
||||
assert.Equal(t, int64(0), block.EthBlockNum)
|
||||
assert.Equal(t, time.Unix(0, 0), block.Timestamp)
|
||||
assert.Equal(t, "0x0000000000000000000000000000000000000000000000000000000000000000", block.Hash.Hex())
|
||||
assert.Equal(t, int64(0), c.blockNum)
|
||||
|
||||
// Mine some empty blocks
|
||||
|
||||
c.CtlMineBlock()
|
||||
assert.Equal(t, int64(1), c.blockNum)
|
||||
c.CtlMineBlock()
|
||||
assert.Equal(t, int64(2), c.blockNum)
|
||||
c.CtlMineBlock()
|
||||
assert.Equal(t, int64(3), c.blockNum)
|
||||
|
||||
block, err = c.EthBlockByNumber(context.TODO(), 2)
|
||||
require.Nil(t, err)
|
||||
@@ -154,14 +154,17 @@ func TestClientRollup(t *testing.T) {
|
||||
var keys [N]*keys
|
||||
for i := 0; i < N; i++ {
|
||||
keys[i] = genKeys(int64(i))
|
||||
l1UserTx := common.L1Tx{
|
||||
tx := common.L1Tx{
|
||||
FromIdx: 0,
|
||||
FromEthAddr: keys[i].Addr,
|
||||
FromBJJ: keys[i].BJJPublicKey,
|
||||
TokenID: common.TokenID(0),
|
||||
Amount: big.NewInt(0),
|
||||
LoadAmount: big.NewInt(10 + int64(i)),
|
||||
}
|
||||
c.CtlAddL1TxUser(&l1UserTx)
|
||||
_, err := c.RollupL1UserTxERC20ETH(tx.FromBJJ, int64(tx.FromIdx), tx.LoadAmount,
|
||||
tx.Amount, uint32(tx.TokenID), int64(tx.ToIdx))
|
||||
require.Nil(t, err)
|
||||
}
|
||||
c.CtlMineBlock()
|
||||
|
||||
@@ -231,8 +234,9 @@ func TestClientRollup(t *testing.T) {
|
||||
rollupEvents, _, err = c.RollupEventsByBlock(blockNum)
|
||||
require.Nil(t, err)
|
||||
|
||||
rollupForgeBatchArgs1, err := c.RollupForgeBatchArgs(rollupEvents.ForgeBatch[0].EthTxHash)
|
||||
rollupForgeBatchArgs1, sender, err := c.RollupForgeBatchArgs(rollupEvents.ForgeBatch[0].EthTxHash)
|
||||
require.Nil(t, err)
|
||||
assert.Equal(t, *c.addr, *sender)
|
||||
assert.Equal(t, rollupForgeBatchArgs0, rollupForgeBatchArgs1)
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user