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

Fix conflicts and update dependencies of ethclient

Browse Source
This commit is contained in:
Eduard S
2020-10-06 16:33:21 +02:00
parent 202b98b3e6
commit 1a85f15d27
12 changed files with 183 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
common/bid.go
View File

@@ -9,7 +9,7 @@ import (
// Bid is a struct that represents one bid in the PoH // Bid is a struct that represents one bid in the PoH
type Bid struct { type Bid struct {
SlotNum SlotNum `meddler:"slot_num"` SlotNum SlotNum `meddler:"slot_num"`
ForgerAddr ethCommon.Address `meddler:"forger_addr"` // Coordinator reference
BidValue *big.Int `meddler:"bid_value,bigint"` BidValue *big.Int `meddler:"bid_value,bigint"`
EthBlockNum int64 `meddler:"eth_block_num"` EthBlockNum int64 `meddler:"eth_block_num"`
Bidder ethCommon.Address `meddler:"bidder_addr"` // Coordinator reference
} }

8
common/coordinator.go
View File

@@ -7,8 +7,8 @@ import (
// Coordinator represents a Hermez network coordinator who wins an auction for an specific slot // Coordinator represents a Hermez network coordinator who wins an auction for an specific slot
// WARNING: this is strongly based on the previous implementation, once the new spec is done, this may change a lot. // WARNING: this is strongly based on the previous implementation, once the new spec is done, this may change a lot.
type Coordinator struct { type Coordinator struct {
Forger ethCommon.Address `meddler:"forger_addr"` // address of the forger Bidder ethCommon.Address `meddler:"bidder_addr"` // address of the bidder
EthBlockNum int64 `meddler:"eth_block_num"` // block in which the coordinator was registered Forger ethCommon.Address `meddler:"forger_addr"` // address of the forger
WithdrawAddr ethCommon.Address `meddler:"withdraw_addr"` // address of the withdraw EthBlockNum int64 `meddler:"eth_block_num"` // block in which the coordinator was registered
URL string `meddler:"url"` // URL of the coordinators API URL string `meddler:"url"` // URL of the coordinators API
} }

11
coordinator/coordinator_test.go
View File

@@ -168,15 +168,16 @@ func TestCoordinator(t *testing.T) {
var timer timer var timer timer
ethClientSetup := test.NewClientSetupExample() ethClientSetup := test.NewClientSetupExample()
addr := ethCommon.HexToAddress("0xc344E203a046Da13b0B4467EB7B3629D0C99F6E6") bidder := ethCommon.HexToAddress("0x6b175474e89094c44da98b954eedeac495271d0f")
ethClient := test.NewClient(true, &timer, &addr, ethClientSetup) forger := ethCommon.HexToAddress("0xc344E203a046Da13b0B4467EB7B3629D0C99F6E6")
ethClient := test.NewClient(true, &timer, &bidder, ethClientSetup)
// Bid for slot 2 and 4 // Bid for slot 2 and 4
_, err := ethClient.AuctionRegisterCoordinator(addr, "https://foo.bar") _, err := ethClient.AuctionSetCoordinator(forger, "https://foo.bar")
require.Nil(t, err) require.Nil(t, err)
_, err = ethClient.AuctionBid(2, big.NewInt(9999), addr) _, err = ethClient.AuctionBid(2, big.NewInt(9999))
require.Nil(t, err) require.Nil(t, err)
_, err = ethClient.AuctionBid(4, big.NewInt(9999), addr) _, err = ethClient.AuctionBid(4, big.NewInt(9999))
require.Nil(t, err) require.Nil(t, err)
c := NewCoordinator(conf, hdb, txsel, bb, serverProofs, ethClient) c := NewCoordinator(conf, hdb, txsel, bb, serverProofs, ethClient)

4
db/historydb/historydb.go
View File

@@ -195,7 +195,7 @@ func (hdb *HistoryDB) addBids(d meddler.DB, bids []common.Bid) error {
// TODO: check the coordinator info // TODO: check the coordinator info
return db.BulkInsert( return db.BulkInsert(
d, d,
"INSERT INTO bid (slot_num, forger_addr, bid_value, eth_block_num) VALUES %s;", "INSERT INTO bid (slot_num, bid_value, eth_block_num, bidder_addr) VALUES %s;",
bids[:], bids[:],
) )
} }
@@ -217,7 +217,7 @@ func (hdb *HistoryDB) AddCoordinators(coordinators []common.Coordinator) error {
func (hdb *HistoryDB) addCoordinators(d meddler.DB, coordinators []common.Coordinator) error { func (hdb *HistoryDB) addCoordinators(d meddler.DB, coordinators []common.Coordinator) error {
return db.BulkInsert( return db.BulkInsert(
d, d,
"INSERT INTO coordinator (forger_addr, eth_block_num, withdraw_addr, url) VALUES %s;", "INSERT INTO coordinator (bidder_addr, forger_addr, eth_block_num, url) VALUES %s;",
coordinators[:], coordinators[:],
) )
} }

6
db/migrations/0001.sql
View File

@@ -8,11 +8,11 @@ CREATE TABLE block (
); );
CREATE TABLE coordinator ( CREATE TABLE coordinator (
bidder_addr BYTEA NOT NULL,
forger_addr BYTEA NOT NULL, forger_addr BYTEA NOT NULL,
eth_block_num BIGINT NOT NULL REFERENCES block (eth_block_num) ON DELETE CASCADE, eth_block_num BIGINT NOT NULL REFERENCES block (eth_block_num) ON DELETE CASCADE,
withdraw_addr BYTEA NOT NULL,
url VARCHAR(200) NOT NULL, url VARCHAR(200) NOT NULL,
PRIMARY KEY (forger_addr, eth_block_num) PRIMARY KEY (bidder_addr, eth_block_num)
); );
CREATE TABLE batch ( CREATE TABLE batch (
@@ -43,7 +43,7 @@ CREATE TABLE bid (
slot_num BIGINT NOT NULL, slot_num BIGINT NOT NULL,
bid_value BYTEA NOT NULL, bid_value BYTEA NOT NULL,
eth_block_num BIGINT NOT NULL REFERENCES block (eth_block_num) ON DELETE CASCADE, eth_block_num BIGINT NOT NULL REFERENCES block (eth_block_num) ON DELETE CASCADE,
forger_addr BYTEA NOT NULL, -- fake foreign key for coordinator bidder_addr BYTEA NOT NULL, -- fake foreign key for coordinator
PRIMARY KEY (slot_num, bid_value) PRIMARY KEY (slot_num, bid_value)
); );

32
eth/auction_test.go
View File

@@ -23,7 +23,8 @@ var genesisBlock = 100
var minBidStr = "10000000000000000000" var minBidStr = "10000000000000000000"
var URL = "http://localhost:3000" var URL = "http://localhost:3000"
var newURL = "http://localhost:3002"
// var newURL = "http://localhost:3002"
var BLOCKSPERSLOT = uint8(40) var BLOCKSPERSLOT = uint8(40)
func TestAuctionGetCurrentSlotNumber(t *testing.T) { func TestAuctionGetCurrentSlotNumber(t *testing.T) {
@@ -43,7 +44,7 @@ func TestAuctionConstants(t *testing.T) {
assert.Equal(t, auctionConstants.GenesisBlockNum, int64(genesisBlock)) assert.Equal(t, auctionConstants.GenesisBlockNum, int64(genesisBlock))
assert.Equal(t, auctionConstants.HermezRollup, hermezRollupAddressTestConst) assert.Equal(t, auctionConstants.HermezRollup, hermezRollupAddressTestConst)
assert.Equal(t, auctionConstants.InitialMinimalBidding, INITMINBID) assert.Equal(t, auctionConstants.InitialMinimalBidding, INITMINBID)
assert.Equal(t, auctionConstants.TokenHEZ, tokenERC777AddressConst) assert.Equal(t, auctionConstants.TokenHEZ, tokenHEZAddressConst)
} }
func TestAuctionVariables(t *testing.T) { func TestAuctionVariables(t *testing.T) {
@@ -244,22 +245,23 @@ func TestAuctionChangeDefaultSlotSetBid(t *testing.T) {
} }
func TestAuctionGetClaimableHEZ(t *testing.T) { func TestAuctionGetClaimableHEZ(t *testing.T) {
forgerAddress := governanceAddressConst bidderAddress := governanceAddressConst
claimableHEZ, err := auctionClientTest.AuctionGetClaimableHEZ(forgerAddress) claimableHEZ, err := auctionClientTest.AuctionGetClaimableHEZ(bidderAddress)
require.Nil(t, err) require.Nil(t, err)
assert.Equal(t, claimableHEZ.Int64(), int64(0)) assert.Equal(t, claimableHEZ.Int64(), int64(0))
} }
func TestAuctionRegisterCoordinator(t *testing.T) { func TestAuctionRegisterCoordinator(t *testing.T) {
forgerAddress := governanceAddressConst forgerAddress := governanceAddressConst
bidderAddress := governanceAddressConst
_, err := auctionClientTest.AuctionSetCoordinator(forgerAddress, URL) _, err := auctionClientTest.AuctionSetCoordinator(forgerAddress, URL)
require.Nil(t, err) require.Nil(t, err)
currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock() currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum) auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
assert.Equal(t, forgerAddress, auctionEvents.SetCoordinator[0].ForgerAddress) assert.Equal(t, forgerAddress, auctionEvents.SetCoordinator[0].ForgerAddress)
assert.Equal(t, forgerAddress, auctionEvents.SetCoordinator[0].BidderAddress) assert.Equal(t, bidderAddress, auctionEvents.SetCoordinator[0].BidderAddress)
assert.Equal(t, URL, auctionEvents.SetCoordinator[0].CoordinatorURL) assert.Equal(t, URL, auctionEvents.SetCoordinator[0].CoordinatorURL)
} }
@@ -268,13 +270,13 @@ func TestAuctionBid(t *testing.T) {
require.Nil(t, err) require.Nil(t, err)
bidAmount := new(big.Int) bidAmount := new(big.Int)
bidAmount.SetString("12000000000000000000", 10) bidAmount.SetString("12000000000000000000", 10)
forgerAddress := governanceAddressConst bidderAddress := governanceAddressConst
_, err = auctionClientTest.AuctionBid(currentSlot+4, bidAmount) _, err = auctionClientTest.AuctionBid(currentSlot+4, bidAmount)
require.Nil(t, err) require.Nil(t, err)
currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock() currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum) auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
assert.Equal(t, bidAmount, auctionEvents.NewBid[0].BidAmount) assert.Equal(t, bidAmount, auctionEvents.NewBid[0].BidAmount)
assert.Equal(t, forgerAddress, auctionEvents.NewBid[0].Bidder) assert.Equal(t, bidderAddress, auctionEvents.NewBid[0].Bidder)
assert.Equal(t, currentSlot+4, auctionEvents.NewBid[0].Slot) assert.Equal(t, currentSlot+4, auctionEvents.NewBid[0].Slot)
} }
@@ -306,27 +308,27 @@ func TestAuctionMultiBid(t *testing.T) {
minBid.SetString("11000000000000000000", 10) minBid.SetString("11000000000000000000", 10)
budget := new(big.Int) budget := new(big.Int)
budget.SetString("45200000000000000000", 10) budget.SetString("45200000000000000000", 10)
forgerAddress := governanceAddressConst bidderAddress := governanceAddressConst
_, err = auctionClientTest.AuctionMultiBid(currentSlot+4, currentSlot+10, slotSet, maxBid, minBid, budget) _, err = auctionClientTest.AuctionMultiBid(currentSlot+4, currentSlot+10, slotSet, maxBid, minBid, budget)
require.Nil(t, err) require.Nil(t, err)
currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock() currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum) auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
assert.Equal(t, forgerAddress, auctionEvents.NewBid[0].Bidder) assert.Equal(t, bidderAddress, auctionEvents.NewBid[0].Bidder)
assert.Equal(t, currentSlot+4, auctionEvents.NewBid[0].Slot) assert.Equal(t, currentSlot+4, auctionEvents.NewBid[0].Slot)
assert.Equal(t, forgerAddress, auctionEvents.NewBid[1].Bidder) assert.Equal(t, bidderAddress, auctionEvents.NewBid[1].Bidder)
assert.Equal(t, currentSlot+6, auctionEvents.NewBid[1].Slot) assert.Equal(t, currentSlot+6, auctionEvents.NewBid[1].Slot)
assert.Equal(t, forgerAddress, auctionEvents.NewBid[2].Bidder) assert.Equal(t, bidderAddress, auctionEvents.NewBid[2].Bidder)
assert.Equal(t, currentSlot+8, auctionEvents.NewBid[2].Slot) assert.Equal(t, currentSlot+8, auctionEvents.NewBid[2].Slot)
assert.Equal(t, forgerAddress, auctionEvents.NewBid[3].Bidder) assert.Equal(t, bidderAddress, auctionEvents.NewBid[3].Bidder)
assert.Equal(t, currentSlot+10, auctionEvents.NewBid[3].Slot) assert.Equal(t, currentSlot+10, auctionEvents.NewBid[3].Slot)
} }
func TestAuctionGetClaimableHEZ2(t *testing.T) { func TestAuctionGetClaimableHEZ2(t *testing.T) {
forgerAddress := governanceAddressConst bidderAddress := governanceAddressConst
amount := new(big.Int) amount := new(big.Int)
amount.SetString("11000000000000000000", 10) amount.SetString("11000000000000000000", 10)
claimableHEZ, err := auctionClientTest.AuctionGetClaimableHEZ(forgerAddress) claimableHEZ, err := auctionClientTest.AuctionGetClaimableHEZ(bidderAddress)
require.Nil(t, err) require.Nil(t, err)
assert.Equal(t, claimableHEZ, amount) assert.Equal(t, claimableHEZ, amount)
} }
@@ -344,7 +346,7 @@ func TestAuctionClaimHEZ(t *testing.T) {
} }
func TestAuctionForge(t *testing.T) { func TestAuctionForge(t *testing.T) {
auctionClientTestHermez, err := NewAuctionClient(ethereumClientHermez, auctionTestAddressConst, tokenERC777AddressConst) auctionClientTestHermez, err := NewAuctionClient(ethereumClientHermez, auctionTestAddressConst, tokenHEZAddressConst)
require.Nil(t, err) require.Nil(t, err)
slotConst := 4 slotConst := 4
blockNum := int64(int(BLOCKSPERSLOT)*slotConst + genesisBlock) blockNum := int64(int(BLOCKSPERSLOT)*slotConst + genesisBlock)

5
eth/main_test.go
View File

@@ -35,8 +35,9 @@ var (
bootCoordinatorAddressConst = ethCommon.HexToAddress(bootCoordinatorAddressStr) bootCoordinatorAddressConst = ethCommon.HexToAddress(bootCoordinatorAddressStr)
tokenERC777AddressStr = "0xf784709d2317D872237C4bC22f867d1BAe2913AB" //nolint:gosec tokenERC777AddressStr = "0xf784709d2317D872237C4bC22f867d1BAe2913AB" //nolint:gosec
tokenERC777AddressConst = ethCommon.HexToAddress(tokenERC777AddressStr) tokenERC777AddressConst = ethCommon.HexToAddress(tokenERC777AddressStr)
tokenERC20AddressStr = "0x3619DbE27d7c1e7E91aA738697Ae7Bc5FC3eACA5" tokenERC20AddressStr = "0x3619DbE27d7c1e7E91aA738697Ae7Bc5FC3eACA5" //nolint:gosec
tokenERC20AddressConst = ethCommon.HexToAddress(tokenERC20AddressStr) tokenERC20AddressConst = ethCommon.HexToAddress(tokenERC20AddressStr)
tokenHEZAddressConst = tokenERC777AddressConst
hermezRollupAddressStr = "0xEcc0a6dbC0bb4D51E4F84A315a9e5B0438cAD4f0" hermezRollupAddressStr = "0xEcc0a6dbC0bb4D51E4F84A315a9e5B0438cAD4f0"
hermezRollupAddressConst = ethCommon.HexToAddress(hermezRollupAddressStr) hermezRollupAddressConst = ethCommon.HexToAddress(hermezRollupAddressStr)
wdelayerAddressStr = "0xD6C850aeBFDC46D7F4c207e445cC0d6B0919BDBe" wdelayerAddressStr = "0xD6C850aeBFDC46D7F4c207e445cC0d6B0919BDBe"
@@ -132,7 +133,7 @@ func TestMain(m *testing.M) {
// Controllable Governance Address // Controllable Governance Address
ethereumClientGov := NewEthereumClient(ethClient, accountGov, ks, nil) ethereumClientGov := NewEthereumClient(ethClient, accountGov, ks, nil)
auctionClientTest, err = NewAuctionClient(ethereumClientGov, auctionTestAddressConst, tokenERC777AddressConst) auctionClientTest, err = NewAuctionClient(ethereumClientGov, auctionTestAddressConst, tokenHEZAddressConst)
if err != nil { if err != nil {
panic(err) panic(err)
} }

82
eth/rollup.go
View File

@@ -5,16 +5,14 @@ import (
"math/big" "math/big"
"strings" "strings"
Hermez "github.com/hermeznetwork/hermez-node/eth/contracts/hermez"
"github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethclient"
ethCommon "github.com/ethereum/go-ethereum/common" ethCommon "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethclient"
"github.com/hermeznetwork/hermez-node/common" "github.com/hermeznetwork/hermez-node/common"
Hermez "github.com/hermeznetwork/hermez-node/eth/contracts/hermez"
"github.com/hermeznetwork/hermez-node/log" "github.com/hermeznetwork/hermez-node/log"
"github.com/iden3/go-iden3-crypto/babyjub" "github.com/iden3/go-iden3-crypto/babyjub"
) )
@@ -40,12 +38,10 @@ const (
// RollupConstL1UserTotalBytes [20 bytes] fromEthAddr + [32 bytes] fromBjj-compressed + [6 bytes] fromIdx + // RollupConstL1UserTotalBytes [20 bytes] fromEthAddr + [32 bytes] fromBjj-compressed + [6 bytes] fromIdx +
// [2 bytes] loadAmountFloat16 + [2 bytes] amountFloat16 + [4 bytes] tokenId + [6 bytes] toIdx // [2 bytes] loadAmountFloat16 + [2 bytes] amountFloat16 + [4 bytes] tokenId + [6 bytes] toIdx
RollupConstL1UserTotalBytes = 72 RollupConstL1UserTotalBytes = 72
// RollupConstMaxL1UserTX Maximum L1-user transactions allowed to be queued in a batch // RollupConstMaxL1UserTx Maximum L1-user transactions allowed to be queued in a batch
RollupConstMaxL1UserTX = 128 RollupConstMaxL1UserTx = 128
// RollupConstMaxL1TX Maximum L1 transactions allowed to be queued in a batch // RollupConstMaxL1Tx Maximum L1 transactions allowed to be queued in a batch
RollupConstMaxL1TX = 256 RollupConstMaxL1Tx = 256
// RollupConstRfield Modulus zkSNARK
RollupConstRfield = 21888242871839275222246405745257275088548364400416034343698204186575808495617
// RollupConstInputSHAConstantBytes [6 bytes] lastIdx + [6 bytes] newLastIdx + [32 bytes] stateRoot + [32 bytes] newStRoot + [32 bytes] newExitRoot + // RollupConstInputSHAConstantBytes [6 bytes] lastIdx + [6 bytes] newLastIdx + [32 bytes] stateRoot + [32 bytes] newStRoot + [32 bytes] newExitRoot +
// [_MAX_L1_TX * _L1_USER_TOTALBYTES bytes] l1TxsData + totalL2TxsDataLength + feeIdxCoordinatorLength + [2 bytes] chainID = // [_MAX_L1_TX * _L1_USER_TOTALBYTES bytes] l1TxsData + totalL2TxsDataLength + feeIdxCoordinatorLength + [2 bytes] chainID =
// 18542 bytes + totalL2TxsDataLength + feeIdxCoordinatorLength // 18542 bytes + totalL2TxsDataLength + feeIdxCoordinatorLength
@@ -65,6 +61,9 @@ var (
// This non-ethereum accounts can be created by the coordinator and allow users to have a rollup // This non-ethereum accounts can be created by the coordinator and allow users to have a rollup
// account without needing an ethereum address // account without needing an ethereum address
RollupConstEthAddressInternalOnly = ethCommon.HexToAddress("0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF") RollupConstEthAddressInternalOnly = ethCommon.HexToAddress("0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF")
// RollupConstRfield Modulus zkSNARK
RollupConstRfield, _ = new(big.Int).SetString(
"21888242871839275222246405745257275088548364400416034343698204186575808495617", 10)
// RollupConstERC1820 ERC1820Registry address // RollupConstERC1820 ERC1820Registry address
RollupConstERC1820 = ethCommon.HexToAddress("0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24") RollupConstERC1820 = ethCommon.HexToAddress("0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24")
@@ -73,8 +72,8 @@ var (
// RollupConstRecipientInterfaceHash ERC777 recipient interface hash // RollupConstRecipientInterfaceHash ERC777 recipient interface hash
RollupConstRecipientInterfaceHash = crypto.Keccak256([]byte("ERC777TokensRecipient")) RollupConstRecipientInterfaceHash = crypto.Keccak256([]byte("ERC777TokensRecipient"))
// RollupConstPerformL1UserTXSignature the signature of the function that can be called thru an ERC777 `send` // RollupConstPerformL1UserTxSignature the signature of the function that can be called thru an ERC777 `send`
RollupConstPerformL1UserTXSignature = crypto.Keccak256([]byte("addL1Transaction(uint256,uint48,uint16,uint16,uint32,uint48)")) RollupConstPerformL1UserTxSignature = crypto.Keccak256([]byte("addL1Transaction(uint256,uint48,uint16,uint16,uint32,uint48)"))
// RollupConstAddTokenSignature the signature of the function that can be called thru an ERC777 `send` // RollupConstAddTokenSignature the signature of the function that can be called thru an ERC777 `send`
RollupConstAddTokenSignature = crypto.Keccak256([]byte("addToken(address)")) RollupConstAddTokenSignature = crypto.Keccak256([]byte("addToken(address)"))
// RollupConstSendSignature ERC777 Signature // RollupConstSendSignature ERC777 Signature
@@ -130,7 +129,7 @@ var (
// RollupPublicConstants are the constants of the Rollup Smart Contract // RollupPublicConstants are the constants of the Rollup Smart Contract
type RollupPublicConstants struct { type RollupPublicConstants struct {
AbsoluteMaxL1L2BatchTimeout uint8 AbsoluteMaxL1L2BatchTimeout int64
TokenHEZ ethCommon.Address TokenHEZ ethCommon.Address
Verifiers []RollupVerifierStruct Verifiers []RollupVerifierStruct
HermezAuctionContract ethCommon.Address HermezAuctionContract ethCommon.Address
@@ -163,8 +162,8 @@ func NewQueueStruct() *QueueStruct {
// RollupVerifierStruct is the information about verifiers of the Rollup Smart Contract // RollupVerifierStruct is the information about verifiers of the Rollup Smart Contract
type RollupVerifierStruct struct { type RollupVerifierStruct struct {
MaxTx *big.Int MaxTx int64
NLevels *big.Int NLevels int64
} }
// RollupState represents the state of the Rollup in the Smart Contract // RollupState represents the state of the Rollup in the Smart Contract
@@ -184,8 +183,8 @@ type RollupState struct {
// RollupEventL1UserTx is an event of the Rollup Smart Contract // RollupEventL1UserTx is an event of the Rollup Smart Contract
type RollupEventL1UserTx struct { type RollupEventL1UserTx struct {
ToForgeL1TxsNum uint64 // QueueIndex *big.Int ToForgeL1TxsNum int64 // QueueIndex *big.Int
Position uint8 // TransactionIndex *big.Int Position int // TransactionIndex *big.Int
L1Tx common.L1Tx L1Tx common.L1Tx
} }
@@ -250,7 +249,7 @@ func NewRollupEvents() RollupEvents {
// RollupForgeBatchArgs are the arguments to the ForgeBatch function in the Rollup Smart Contract // RollupForgeBatchArgs are the arguments to the ForgeBatch function in the Rollup Smart Contract
//nolint:structcheck,unused //nolint:structcheck,unused
type RollupForgeBatchArgs struct { type RollupForgeBatchArgs struct {
NewLastIdx uint64 NewLastIdx int64
NewStRoot *big.Int NewStRoot *big.Int
NewExitRoot *big.Int NewExitRoot *big.Int
L1CoordinatorTxs []*common.L1Tx L1CoordinatorTxs []*common.L1Tx
@@ -453,23 +452,24 @@ func (c *RollupClient) RollupConstants() (*RollupPublicConstants, error) {
if err != nil { if err != nil {
return err return err
} }
rollupConstants.AbsoluteMaxL1L2BatchTimeout, err = hermez.ABSOLUTEMAXL1L2BATCHTIMEOUT(nil) absoluteMaxL1L2BatchTimeout, err := hermez.ABSOLUTEMAXL1L2BATCHTIMEOUT(nil)
if err != nil { if err != nil {
return err return err
} }
rollupConstants.AbsoluteMaxL1L2BatchTimeout = int64(absoluteMaxL1L2BatchTimeout)
rollupConstants.TokenHEZ, err = hermez.TokenHEZ(nil) rollupConstants.TokenHEZ, err = hermez.TokenHEZ(nil)
if err != nil { if err != nil {
return err return err
} }
for i := int64(0); i < int64(LenVerifiers); i++ { for i := int64(0); i < int64(LenVerifiers); i++ {
newRollupVerifier := new(RollupVerifierStruct) var newRollupVerifier RollupVerifierStruct
rollupVerifier, err := hermez.RollupVerifiers(nil, big.NewInt(i)) rollupVerifier, err := hermez.RollupVerifiers(nil, big.NewInt(i))
if err != nil { if err != nil {
return err return err
} }
newRollupVerifier.MaxTx = rollupVerifier.MaxTx newRollupVerifier.MaxTx = rollupVerifier.MaxTx.Int64()
newRollupVerifier.NLevels = rollupVerifier.NLevels newRollupVerifier.NLevels = rollupVerifier.NLevels.Int64()
rollupConstants.Verifiers = append(rollupConstants.Verifiers, *newRollupVerifier) rollupConstants.Verifiers = append(rollupConstants.Verifiers, newRollupVerifier)
} }
rollupConstants.HermezAuctionContract, err = hermez.HermezAuctionContract(nil) rollupConstants.HermezAuctionContract, err = hermez.HermezAuctionContract(nil)
if err != nil { if err != nil {
@@ -492,7 +492,7 @@ func (c *RollupClient) RollupConstants() (*RollupPublicConstants, error) {
} }
var ( var (
logHermezL1UserTXEvent = crypto.Keccak256Hash([]byte("L1UserTxEvent(uint64,uint8,bytes)")) logHermezL1UserTxEvent = crypto.Keccak256Hash([]byte("L1UserTxEvent(uint64,uint8,bytes)"))
logHermezAddToken = crypto.Keccak256Hash([]byte("AddToken(address,uint32)")) logHermezAddToken = crypto.Keccak256Hash([]byte("AddToken(address,uint32)"))
logHermezForgeBatch = crypto.Keccak256Hash([]byte("ForgeBatch(uint64)")) logHermezForgeBatch = crypto.Keccak256Hash([]byte("ForgeBatch(uint64)"))
logHermezUpdateForgeL1L2BatchTimeout = crypto.Keccak256Hash([]byte("UpdateForgeL1L2BatchTimeout(uint8)")) logHermezUpdateForgeL1L2BatchTimeout = crypto.Keccak256Hash([]byte("UpdateForgeL1L2BatchTimeout(uint8)"))
@@ -526,7 +526,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethC
return nil, nil, ErrBlockHashMismatchEvent return nil, nil, ErrBlockHashMismatchEvent
} }
switch vLog.Topics[0] { switch vLog.Topics[0] {
case logHermezL1UserTXEvent: case logHermezL1UserTxEvent:
var L1UserTxAux RollupEventL1UserTxAux var L1UserTxAux RollupEventL1UserTxAux
var L1UserTx RollupEventL1UserTx var L1UserTx RollupEventL1UserTx
err := c.contractAbi.Unpack(&L1UserTxAux, "L1UserTxEvent", vLog.Data) err := c.contractAbi.Unpack(&L1UserTxAux, "L1UserTxEvent", vLog.Data)
@@ -537,8 +537,8 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethC
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
} }
L1UserTx.ToForgeL1TxsNum = new(big.Int).SetBytes(vLog.Topics[1][:]).Uint64() L1UserTx.ToForgeL1TxsNum = new(big.Int).SetBytes(vLog.Topics[1][:]).Int64()
L1UserTx.Position = uint8(new(big.Int).SetBytes(vLog.Topics[2][:]).Uint64()) L1UserTx.Position = int(new(big.Int).SetBytes(vLog.Topics[2][:]).Int64())
L1UserTx.L1Tx = *L1Tx L1UserTx.L1Tx = *L1Tx
rollupEvents.L1UserTx = append(rollupEvents.L1UserTx, L1UserTx) rollupEvents.L1UserTx = append(rollupEvents.L1UserTx, L1UserTx)
case logHermezAddToken: case logHermezAddToken:
@@ -552,6 +552,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethC
case logHermezForgeBatch: case logHermezForgeBatch:
var forgeBatch RollupEventForgeBatch var forgeBatch RollupEventForgeBatch
forgeBatch.BatchNum = new(big.Int).SetBytes(vLog.Topics[1][:]).Int64() forgeBatch.BatchNum = new(big.Int).SetBytes(vLog.Topics[1][:]).Int64()
forgeBatch.EthTxHash = vLog.TxHash
rollupEvents.ForgeBatch = append(rollupEvents.ForgeBatch, forgeBatch) rollupEvents.ForgeBatch = append(rollupEvents.ForgeBatch, forgeBatch)
case logHermezUpdateForgeL1L2BatchTimeout: case logHermezUpdateForgeL1L2BatchTimeout:
var updateForgeL1L2BatchTimeout RollupEventUpdateForgeL1L2BatchTimeout var updateForgeL1L2BatchTimeout RollupEventUpdateForgeL1L2BatchTimeout
@@ -592,12 +593,14 @@ func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash) (*RollupFo
if err != nil { if err != nil {
return nil, err return nil, err
} }
aux := new(RollupForgeBatchArgsAux) var aux RollupForgeBatchArgsAux
method.Inputs.Unpack(aux, txData) if err := method.Inputs.Unpack(&aux, txData); err != nil {
rollupForgeBatchArgs := new(RollupForgeBatchArgs) return nil, err
}
var rollupForgeBatchArgs RollupForgeBatchArgs
rollupForgeBatchArgs.L1Batch = aux.L1Batch rollupForgeBatchArgs.L1Batch = aux.L1Batch
rollupForgeBatchArgs.NewExitRoot = aux.NewExitRoot rollupForgeBatchArgs.NewExitRoot = aux.NewExitRoot
rollupForgeBatchArgs.NewLastIdx = aux.NewLastIdx rollupForgeBatchArgs.NewLastIdx = int64(aux.NewLastIdx)
rollupForgeBatchArgs.NewStRoot = aux.NewStRoot rollupForgeBatchArgs.NewStRoot = aux.NewStRoot
rollupForgeBatchArgs.ProofA = aux.ProofA rollupForgeBatchArgs.ProofA = aux.ProofA
rollupForgeBatchArgs.ProofB = aux.ProofB rollupForgeBatchArgs.ProofB = aux.ProofB
@@ -606,30 +609,31 @@ func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash) (*RollupFo
numTxsL1 := len(aux.L1CoordinatorTxs) / common.L1TxBytesLen numTxsL1 := len(aux.L1CoordinatorTxs) / common.L1TxBytesLen
for i := 0; i < numTxsL1; i++ { for i := 0; i < numTxsL1; i++ {
L1Tx, err := common.L1TxFromCoordinatorBytes(aux.L1CoordinatorTxs[i*common.L1CoordinatorTxBytesLen : (i+1)*common.L1CoordinatorTxBytesLen]) l1Tx, err := common.L1TxFromCoordinatorBytes(aux.L1CoordinatorTxs[i*common.L1CoordinatorTxBytesLen : (i+1)*common.L1CoordinatorTxBytesLen])
if err != nil { if err != nil {
return nil, err return nil, err
} }
rollupForgeBatchArgs.L1CoordinatorTxs = append(rollupForgeBatchArgs.L1CoordinatorTxs, L1Tx) rollupForgeBatchArgs.L1CoordinatorTxs = append(rollupForgeBatchArgs.L1CoordinatorTxs, l1Tx)
} }
rollupConsts, err := c.RollupConstants() rollupConsts, err := c.RollupConstants()
if err != nil { if err != nil {
return nil, err return nil, err
} }
nLevels := rollupConsts.Verifiers[rollupForgeBatchArgs.VerifierIdx].NLevels.Int64() nLevels := rollupConsts.Verifiers[rollupForgeBatchArgs.VerifierIdx].NLevels
lenL2TxsBytes := int((nLevels/8)*2 + 2 + 1) lenL2TxsBytes := int((nLevels/8)*2 + 2 + 1)
numTxsL2 := len(aux.L2TxsData) / lenL2TxsBytes numTxsL2 := len(aux.L2TxsData) / lenL2TxsBytes
for i := 0; i < numTxsL2; i++ { for i := 0; i < numTxsL2; i++ {
L2Tx, err := common.L2TxFromBytes(aux.L2TxsData[i*lenL2TxsBytes:(i+1)*lenL2TxsBytes], int(nLevels)) l2Tx, err := common.L2TxFromBytes(aux.L2TxsData[i*lenL2TxsBytes:(i+1)*lenL2TxsBytes], int(nLevels))
if err != nil { if err != nil {
return nil, err return nil, err
} }
rollupForgeBatchArgs.L2TxsData = append(rollupForgeBatchArgs.L2TxsData, L2Tx) rollupForgeBatchArgs.L2TxsData = append(rollupForgeBatchArgs.L2TxsData, l2Tx)
} }
lenFeeIdxCoordinatorBytes := int(nLevels / 8) lenFeeIdxCoordinatorBytes := int(nLevels / 8) //nolint:gomnd
numFeeIdxCoordinator := len(aux.FeeIdxCoordinator) / lenFeeIdxCoordinatorBytes numFeeIdxCoordinator := len(aux.FeeIdxCoordinator) / lenFeeIdxCoordinatorBytes
for i := 0; i < numFeeIdxCoordinator; i++ { for i := 0; i < numFeeIdxCoordinator; i++ {
var paddedFeeIdx [6]byte var paddedFeeIdx [6]byte
// TODO: This check is not necessary: the first case will always work. Test it before removing the if.
if lenFeeIdxCoordinatorBytes < common.IdxBytesLen { if lenFeeIdxCoordinatorBytes < common.IdxBytesLen {
copy(paddedFeeIdx[6-lenFeeIdxCoordinatorBytes:], aux.FeeIdxCoordinator[i*lenFeeIdxCoordinatorBytes:(i+1)*lenFeeIdxCoordinatorBytes]) copy(paddedFeeIdx[6-lenFeeIdxCoordinatorBytes:], aux.FeeIdxCoordinator[i*lenFeeIdxCoordinatorBytes:(i+1)*lenFeeIdxCoordinatorBytes])
} else { } else {
@@ -641,7 +645,7 @@ func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash) (*RollupFo
} }
rollupForgeBatchArgs.FeeIdxCoordinator = append(rollupForgeBatchArgs.FeeIdxCoordinator, FeeIdxCoordinator) rollupForgeBatchArgs.FeeIdxCoordinator = append(rollupForgeBatchArgs.FeeIdxCoordinator, FeeIdxCoordinator)
} }
return rollupForgeBatchArgs, nil return &rollupForgeBatchArgs, nil
// tx := client.TransactionByHash(ethTxHash) -> types.Transaction // tx := client.TransactionByHash(ethTxHash) -> types.Transaction
// txData := types.Transaction -> Data() // txData := types.Transaction -> Data()
// m := abi.MethodById(txData) -> Method // m := abi.MethodById(txData) -> Method

24
synchronizer/synchronizer.go
View File

@@ -429,7 +429,7 @@ func (s *Synchronizer) rollupSync(blockNum int64) (*rollupData, error) {
} }
// Get L2Txs // Get L2Txs
poolL2Txs := common.L2TxsToPoolL2Txs(forgeBatchArgs.L2Txs) // TODO: This is a big uggly, find a better way poolL2Txs := common.L2TxsToPoolL2Txs(forgeBatchArgs.L2TxsData) // TODO: This is a big uggly, find a better way
// Get exitTree // Get exitTree
// TODO: Get createdAccounts from ProcessTxs() // TODO: Get createdAccounts from ProcessTxs()
@@ -502,18 +502,18 @@ func (s *Synchronizer) auctionSync(blockNum int64) (*auctionData, error) {
bid := &common.Bid{ bid := &common.Bid{
SlotNum: common.SlotNum(eNewBid.Slot), SlotNum: common.SlotNum(eNewBid.Slot),
BidValue: eNewBid.BidAmount, BidValue: eNewBid.BidAmount,
ForgerAddr: eNewBid.CoordinatorForger, Bidder: eNewBid.Bidder,
EthBlockNum: blockNum, EthBlockNum: blockNum,
} }
auctionData.bids = append(auctionData.bids, bid) auctionData.bids = append(auctionData.bids, bid)
} }
// Get Coordinators // Get Coordinators
for _, eNewCoordinator := range auctionEvents.NewCoordinator { for _, eNewCoordinator := range auctionEvents.SetCoordinator {
coordinator := &common.Coordinator{ coordinator := &common.Coordinator{
Forger: eNewCoordinator.ForgerAddress, Bidder: eNewCoordinator.BidderAddress,
WithdrawAddr: eNewCoordinator.WithdrawalAddress, Forger: eNewCoordinator.ForgerAddress,
URL: eNewCoordinator.CoordinatorURL, URL: eNewCoordinator.CoordinatorURL,
} }
auctionData.coordinators = append(auctionData.coordinators, coordinator) auctionData.coordinators = append(auctionData.coordinators, coordinator)
} }
@@ -530,18 +530,6 @@ func (s *Synchronizer) auctionSync(blockNum int64) (*auctionData, error) {
// TODO: NewForge // TODO: NewForge
// TODO: HEZClaimed // TODO: HEZClaimed
// TODO: Think about separating new coordinaors from coordinator updated
// Get Coordinators from updates
for _, eCoordinatorUpdated := range auctionEvents.CoordinatorUpdated {
coordinator := &common.Coordinator{
Forger: eCoordinatorUpdated.ForgerAddress,
WithdrawAddr: eCoordinatorUpdated.WithdrawalAddress,
URL: eCoordinatorUpdated.CoordinatorURL,
}
auctionData.coordinators = append(auctionData.coordinators, coordinator)
}
// TODO: VARS // TODO: VARS
// TODO: CONSTANTS // TODO: CONSTANTS

132
test/ethclient.go
View File

@@ -34,7 +34,7 @@ type RollupBlock struct {
Vars eth.RollupVariables Vars eth.RollupVariables
Events eth.RollupEvents Events eth.RollupEvents
Txs map[ethCommon.Hash]*types.Transaction Txs map[ethCommon.Hash]*types.Transaction
Constants *eth.RollupConstants Constants *eth.RollupPublicConstants
Eth *EthereumBlock Eth *EthereumBlock
} }
@@ -128,7 +128,7 @@ func (a *AuctionBlock) forge(forger ethCommon.Address) error {
a.Events.NewForge = append(a.Events.NewForge, eth.AuctionEventNewForge{ a.Events.NewForge = append(a.Events.NewForge, eth.AuctionEventNewForge{
Forger: forger, Forger: forger,
CurrentSlot: slotToForge, SlotToForge: slotToForge,
}) })
return nil return nil
} }
@@ -159,7 +159,9 @@ func (a *AuctionBlock) canForge(forger ethCommon.Address, blockNum int64) (bool,
if !slotState.Fulfilled && (relativeBlock >= int64(a.Vars.SlotDeadline)) { if !slotState.Fulfilled && (relativeBlock >= int64(a.Vars.SlotDeadline)) {
// if the relative block has exceeded the slotDeadline and no batch has been forged, anyone can forge // if the relative block has exceeded the slotDeadline and no batch has been forged, anyone can forge
return true, nil return true, nil
} else if slotState.Forger == forger && slotState.BidAmount.Cmp(minBid) >= 0 { // TODO, find the forger set by the Bidder
} else if coord, ok := a.State.Coordinators[slotState.Bidder]; ok &&
coord.Forger == forger && slotState.BidAmount.Cmp(minBid) >= 0 {
// if forger bidAmount has exceeded the minBid it can forge // if forger bidAmount has exceeded the minBid it can forge
return true, nil return true, nil
} else if a.Vars.BootCoordinator == forger && slotState.BidAmount.Cmp(minBid) == -1 { } else if a.Vars.BootCoordinator == forger && slotState.BidAmount.Cmp(minBid) == -1 {
@@ -214,7 +216,7 @@ func (b *Block) Next() *Block {
// ClientSetup is used to initialize the constants of the Smart Contracts and // ClientSetup is used to initialize the constants of the Smart Contracts and
// other details of the test Client // other details of the test Client
type ClientSetup struct { type ClientSetup struct {
RollupConstants *eth.RollupConstants RollupConstants *eth.RollupPublicConstants
RollupVariables *eth.RollupVariables RollupVariables *eth.RollupVariables
AuctionConstants *eth.AuctionConstants AuctionConstants *eth.AuctionConstants
AuctionVariables *eth.AuctionVariables AuctionVariables *eth.AuctionVariables
@@ -224,36 +226,33 @@ type ClientSetup struct {
// NewClientSetupExample returns a ClientSetup example with hardcoded realistic values. // NewClientSetupExample returns a ClientSetup example with hardcoded realistic values.
//nolint:gomnd //nolint:gomnd
func NewClientSetupExample() *ClientSetup { func NewClientSetupExample() *ClientSetup {
rfield, ok := new(big.Int).SetString("21888242871839275222246405745257275088548364400416034343698204186575808495617", 10) // rfield, ok := new(big.Int).SetString("21888242871839275222246405745257275088548364400416034343698204186575808495617", 10)
if !ok { // if !ok {
panic("bad rfield") // panic("bad rfield")
} // }
initialMinimalBidding, ok := new(big.Int).SetString("10000000000000000000", 10) // 10 * (1e18) initialMinimalBidding, ok := new(big.Int).SetString("10000000000000000000", 10) // 10 * (1e18)
if !ok { if !ok {
panic("bad initialMinimalBidding") panic("bad initialMinimalBidding")
} }
tokenHEZ := ethCommon.HexToAddress("0x51D243D62852Bba334DD5cc33f242BAc8c698074") tokenHEZ := ethCommon.HexToAddress("0x51D243D62852Bba334DD5cc33f242BAc8c698074")
governanceAddress := ethCommon.HexToAddress("0x688EfD95BA4391f93717CF02A9aED9DBD2855cDd") governanceAddress := ethCommon.HexToAddress("0x688EfD95BA4391f93717CF02A9aED9DBD2855cDd")
rollupConstants := &eth.RollupConstants{ rollupConstants := &eth.RollupPublicConstants{
MaxAmountDeposit: new(big.Int).Lsh(big.NewInt(1), 128), Verifiers: []eth.RollupVerifierStruct{
MaxAmountL2: new(big.Int).Lsh(big.NewInt(1), 192), {
MaxTokens: 0xffffffff, MaxTx: 2048,
MaxL1Tx: 256, NLevels: 32,
MaxL1UserTx: 128, },
Rfield: rfield, },
L1CoordinatorBytes: 101, TokenHEZ: tokenHEZ,
L1UserBytes: 68, HermezGovernanceDAOAddress: governanceAddress,
L2Bytes: 11, SafetyAddress: ethCommon.HexToAddress("0x84d8B79E84fe87B14ad61A554e740f6736bF4c20"),
MaxTxVerifiers: []int{512, 1024, 2048}, HermezAuctionContract: ethCommon.HexToAddress("0x8E442975805fb1908f43050c9C1A522cB0e28D7b"),
TokenHEZ: tokenHEZ, WithdrawDelayerContract: ethCommon.HexToAddress("0x5CB7979cBdbf65719BEE92e4D15b7b7Ed3D79114"),
GovernanceAddress: governanceAddress,
SafetyBot: ethCommon.HexToAddress("0x84d8B79E84fe87B14ad61A554e740f6736bF4c20"),
ConsensusContract: ethCommon.HexToAddress("0x8E442975805fb1908f43050c9C1A522cB0e28D7b"),
WithdrawalContract: ethCommon.HexToAddress("0x5CB7979cBdbf65719BEE92e4D15b7b7Ed3D79114"),
} }
rollupVariables := &eth.RollupVariables{ rollupVariables := &eth.RollupVariables{
FeeAddToken: big.NewInt(11), FeeAddToken: big.NewInt(11),
ForgeL1Timeout: 9, ForgeL1L2BatchTimeout: 9,
WithdrawalDelay: 80,
} }
auctionConstants := &eth.AuctionConstants{ auctionConstants := &eth.AuctionConstants{
BlocksPerSlot: 40, BlocksPerSlot: 40,
@@ -301,7 +300,7 @@ type Client struct {
rw *sync.RWMutex rw *sync.RWMutex
log bool log bool
addr *ethCommon.Address addr *ethCommon.Address
rollupConstants *eth.RollupConstants rollupConstants *eth.RollupPublicConstants
auctionConstants *eth.AuctionConstants auctionConstants *eth.AuctionConstants
blocks map[int64]*Block blocks map[int64]*Block
// state state // state state
@@ -431,6 +430,11 @@ func (c *Client) currentBlock() *Block {
return c.blocks[c.blockNum] return c.blocks[c.blockNum]
} }
// CtlSetAddr sets the address of the client
func (c *Client) CtlSetAddr(addr ethCommon.Address) {
c.addr = &addr
}
// CtlMineBlock moves one block forward // CtlMineBlock moves one block forward
func (c *Client) CtlMineBlock() { func (c *Client) CtlMineBlock() {
c.rw.Lock() c.rw.Lock()
@@ -561,7 +565,7 @@ func (c *Client) CtlAddL1TxUser(l1Tx *common.L1Tx) {
nextBlock := c.nextBlock() nextBlock := c.nextBlock()
r := nextBlock.Rollup r := nextBlock.Rollup
queue := r.State.MapL1TxQueue[r.State.LastToForgeL1TxsNum] queue := r.State.MapL1TxQueue[r.State.LastToForgeL1TxsNum]
if len(queue.L1TxQueue) >= c.rollupConstants.MaxL1UserTx { if len(queue.L1TxQueue) >= eth.RollupConstMaxL1UserTx {
r.State.LastToForgeL1TxsNum++ r.State.LastToForgeL1TxsNum++
r.State.MapL1TxQueue[r.State.LastToForgeL1TxsNum] = eth.NewQueueStruct() r.State.MapL1TxQueue[r.State.LastToForgeL1TxsNum] = eth.NewQueueStruct()
queue = r.State.MapL1TxQueue[r.State.LastToForgeL1TxsNum] queue = r.State.MapL1TxQueue[r.State.LastToForgeL1TxsNum]
@@ -881,7 +885,7 @@ func (c *Client) RollupUpdateFeeAddToken(newFeeAddToken *big.Int) (tx *types.Tra
// } // }
// RollupConstants returns the Constants of the Rollup Smart Contract // RollupConstants returns the Constants of the Rollup Smart Contract
func (c *Client) RollupConstants() (*eth.RollupConstants, error) { func (c *Client) RollupConstants() (*eth.RollupPublicConstants, error) {
c.rw.RLock() c.rw.RLock()
defer c.rw.RUnlock() defer c.rw.RUnlock()
@@ -1094,8 +1098,8 @@ func (c *Client) AuctionChangeDefaultSlotSetBid(slotSet int64, newInitialMinBid
return nil, errTODO return nil, errTODO
} }
// AuctionRegisterCoordinator is the interface to call the smart contract function // AuctionSetCoordinator is the interface to call the smart contract function
func (c *Client) AuctionRegisterCoordinator(forgerAddress ethCommon.Address, URL string) (tx *types.Transaction, err error) { func (c *Client) AuctionSetCoordinator(forger ethCommon.Address, URL string) (tx *types.Transaction, err error) {
c.rw.Lock() c.rw.Lock()
defer c.rw.Unlock() defer c.rw.Unlock()
cpy := c.nextBlock().copy() cpy := c.nextBlock().copy()
@@ -1107,26 +1111,24 @@ func (c *Client) AuctionRegisterCoordinator(forgerAddress ethCommon.Address, URL
nextBlock := c.nextBlock() nextBlock := c.nextBlock()
a := nextBlock.Auction a := nextBlock.Auction
if _, ok := a.State.Coordinators[forgerAddress]; ok { a.State.Coordinators[*c.addr] = &eth.Coordinator{
return nil, fmt.Errorf("Already registered") Forger: forger,
} URL: URL,
a.State.Coordinators[forgerAddress] = &eth.Coordinator{
WithdrawalAddress: *c.addr,
URL: URL,
} }
a.Events.NewCoordinator = append(a.Events.NewCoordinator, a.Events.SetCoordinator = append(a.Events.SetCoordinator,
eth.AuctionEventNewCoordinator{ eth.AuctionEventSetCoordinator{
ForgerAddress: forgerAddress, BidderAddress: *c.addr,
WithdrawalAddress: *c.addr, ForgerAddress: forger,
CoordinatorURL: URL, CoordinatorURL: URL,
}) })
type data struct { type data struct {
BidderAddress ethCommon.Address
ForgerAddress ethCommon.Address ForgerAddress ethCommon.Address
URL string URL string
} }
return a.addTransaction(newTransaction("registercoordinator", data{forgerAddress, URL})), nil return a.addTransaction(newTransaction("registercoordinator", data{*c.addr, forger, URL})), nil
} }
// AuctionIsRegisteredCoordinator is the interface to call the smart contract function // AuctionIsRegisteredCoordinator is the interface to call the smart contract function
@@ -1204,7 +1206,7 @@ func (c *Client) AuctionGetSlotSet(slot int64) (*big.Int, error) {
// } // }
// AuctionBid is the interface to call the smart contract function // AuctionBid is the interface to call the smart contract function
func (c *Client) AuctionBid(slot int64, bidAmount *big.Int, forger ethCommon.Address) (tx *types.Transaction, err error) { func (c *Client) AuctionBid(slot int64, bidAmount *big.Int) (tx *types.Transaction, err error) {
c.rw.Lock() c.rw.Lock()
defer c.rw.Unlock() defer c.rw.Unlock()
cpy := c.nextBlock().copy() cpy := c.nextBlock().copy()
@@ -1232,7 +1234,7 @@ func (c *Client) AuctionBid(slot int64, bidAmount *big.Int, forger ethCommon.Add
return nil, errBidBelowMin return nil, errBidBelowMin
} }
if _, ok := a.State.Coordinators[forger]; !ok { if _, ok := a.State.Coordinators[*c.addr]; !ok {
return nil, errCoordNotReg return nil, errCoordNotReg
} }
@@ -1241,22 +1243,22 @@ func (c *Client) AuctionBid(slot int64, bidAmount *big.Int, forger ethCommon.Add
slotState = eth.NewSlotState() slotState = eth.NewSlotState()
a.State.Slots[slot] = slotState a.State.Slots[slot] = slotState
} }
slotState.Forger = forger slotState.Bidder = *c.addr
slotState.BidAmount = bidAmount slotState.BidAmount = bidAmount
a.Events.NewBid = append(a.Events.NewBid, a.Events.NewBid = append(a.Events.NewBid,
eth.AuctionEventNewBid{Slot: slot, BidAmount: bidAmount, CoordinatorForger: forger}) eth.AuctionEventNewBid{Slot: slot, BidAmount: bidAmount, Bidder: *c.addr})
type data struct { type data struct {
Slot int64 Slot int64
BidAmount *big.Int BidAmount *big.Int
Forger ethCommon.Address Bidder ethCommon.Address
} }
return a.addTransaction(newTransaction("bid", data{slot, bidAmount, forger})), nil return a.addTransaction(newTransaction("bid", data{slot, bidAmount, *c.addr})), nil
} }
// AuctionMultiBid is the interface to call the smart contract function // AuctionMultiBid is the interface to call the smart contract function
func (c *Client) AuctionMultiBid(startingSlot int64, endingSlot int64, slotSet [6]bool, maxBid, closedMinBid, budget *big.Int, forger ethCommon.Address) (tx *types.Transaction, err error) { func (c *Client) AuctionMultiBid(startingSlot int64, endingSlot int64, slotSet [6]bool, maxBid, closedMinBid, budget *big.Int) (tx *types.Transaction, err error) {
c.rw.Lock() c.rw.Lock()
defer c.rw.Unlock() defer c.rw.Unlock()
cpy := c.nextBlock().copy() cpy := c.nextBlock().copy()
@@ -1280,12 +1282,7 @@ func (c *Client) AuctionCanForge(forger ethCommon.Address, blockNum int64) (bool
} }
// AuctionForge is the interface to call the smart contract function // AuctionForge is the interface to call the smart contract function
// func (c *Client) AuctionForge(forger ethCommon.Address) (bool, error) { func (c *Client) AuctionForge(forger ethCommon.Address) (tx *types.Transaction, err error) {
// return false, errTODO
// }
// AuctionClaimHEZ is the interface to call the smart contract function
func (c *Client) AuctionClaimHEZ(claimAddress ethCommon.Address) (tx *types.Transaction, err error) {
c.rw.Lock() c.rw.Lock()
defer c.rw.Unlock() defer c.rw.Unlock()
cpy := c.nextBlock().copy() cpy := c.nextBlock().copy()
@@ -1298,6 +1295,29 @@ func (c *Client) AuctionClaimHEZ(claimAddress ethCommon.Address) (tx *types.Tran
return nil, errTODO return nil, errTODO
} }
// AuctionClaimHEZ is the interface to call the smart contract function
func (c *Client) AuctionClaimHEZ() (tx *types.Transaction, err error) {
c.rw.Lock()
defer c.rw.Unlock()
cpy := c.nextBlock().copy()
defer func() { c.revertIfErr(err, cpy) }()
if c.addr == nil {
return nil, eth.ErrAccountNil
}
log.Error("TODO")
return nil, errTODO
}
// AuctionGetClaimableHEZ is the interface to call the smart contract function
func (c *Client) AuctionGetClaimableHEZ(bidder ethCommon.Address) (*big.Int, error) {
c.rw.RLock()
defer c.rw.RUnlock()
log.Error("TODO")
return nil, errTODO
}
// AuctionConstants returns the Constants of the Auction Smart Contract // AuctionConstants returns the Constants of the Auction Smart Contract
func (c *Client) AuctionConstants() (*eth.AuctionConstants, error) { func (c *Client) AuctionConstants() (*eth.AuctionConstants, error) {
c.rw.RLock() c.rw.RLock()

32
test/ethclient_test.go
View File

@@ -65,7 +65,8 @@ func TestClientEth(t *testing.T) {
} }
func TestClientAuction(t *testing.T) { func TestClientAuction(t *testing.T) {
addrWithdraw := ethCommon.HexToAddress("0x6b175474e89094c44da98b954eedeac495271d0f") addrBidder1 := ethCommon.HexToAddress("0x6b175474e89094c44da98b954eedeac495271d0f")
addrBidder2 := ethCommon.HexToAddress("0xc27cadc437d067a6ec869502cc9f7F834cFc087a")
addrForge := ethCommon.HexToAddress("0xCfAA413eEb796f328620a3630Ae39124cabcEa92") addrForge := ethCommon.HexToAddress("0xCfAA413eEb796f328620a3630Ae39124cabcEa92")
addrForge2 := ethCommon.HexToAddress("0x1fCb4ac309428feCc61B1C8cA5823C15A5e1a800") addrForge2 := ethCommon.HexToAddress("0x1fCb4ac309428feCc61B1C8cA5823C15A5e1a800")
@@ -76,37 +77,38 @@ func TestClientAuction(t *testing.T) {
clientSetup.AuctionVariables.DefaultSlotSetBid = [6]*big.Int{ clientSetup.AuctionVariables.DefaultSlotSetBid = [6]*big.Int{
big.NewInt(1000), big.NewInt(1100), big.NewInt(1200), big.NewInt(1000), big.NewInt(1100), big.NewInt(1200),
big.NewInt(1300), big.NewInt(1400), big.NewInt(1500)} big.NewInt(1300), big.NewInt(1400), big.NewInt(1500)}
c := NewClient(true, &timer, &addrWithdraw, clientSetup) c := NewClient(true, &timer, &addrBidder1, clientSetup)
// Check several cases in which bid doesn't succed, and also do 2 successful bids. // Check several cases in which bid doesn't succed, and also do 2 successful bids.
_, err := c.AuctionBid(0, big.NewInt(1), addrForge) _, err := c.AuctionBid(0, big.NewInt(1))
assert.Equal(t, errBidClosed, err) assert.Equal(t, errBidClosed, err)
_, err = c.AuctionBid(4322, big.NewInt(1), addrForge) _, err = c.AuctionBid(4322, big.NewInt(1))
assert.Equal(t, errBidNotOpen, err) assert.Equal(t, errBidNotOpen, err)
// 101 % 6 = 5; defaultSlotSetBid[5] = 1500; 1500 + 10% = 1650 // 101 % 6 = 5; defaultSlotSetBid[5] = 1500; 1500 + 10% = 1650
_, err = c.AuctionBid(101, big.NewInt(1650), addrForge) _, err = c.AuctionBid(101, big.NewInt(1650))
assert.Equal(t, errCoordNotReg, err) assert.Equal(t, errCoordNotReg, err)
_, err = c.AuctionRegisterCoordinator(addrForge, "https://foo.bar") _, err = c.AuctionSetCoordinator(addrForge, "https://foo.bar")
assert.Nil(t, err) assert.Nil(t, err)
_, err = c.AuctionBid(3, big.NewInt(1), addrForge) _, err = c.AuctionBid(3, big.NewInt(1))
assert.Equal(t, errBidBelowMin, err) assert.Equal(t, errBidBelowMin, err)
_, err = c.AuctionBid(3, big.NewInt(1650), addrForge) _, err = c.AuctionBid(3, big.NewInt(1650))
assert.Nil(t, err) assert.Nil(t, err)
_, err = c.AuctionRegisterCoordinator(addrForge2, "https://foo2.bar") c.CtlSetAddr(addrBidder2)
_, err = c.AuctionSetCoordinator(addrForge2, "https://foo2.bar")
assert.Nil(t, err) assert.Nil(t, err)
_, err = c.AuctionBid(3, big.NewInt(16), addrForge2) _, err = c.AuctionBid(3, big.NewInt(16))
assert.Equal(t, errBidBelowMin, err) assert.Equal(t, errBidBelowMin, err)
// 1650 + 10% = 1815 // 1650 + 10% = 1815
_, err = c.AuctionBid(3, big.NewInt(1815), addrForge2) _, err = c.AuctionBid(3, big.NewInt(1815))
assert.Nil(t, err) assert.Nil(t, err)
c.CtlMineBlock() c.CtlMineBlock()
@@ -164,8 +166,8 @@ func TestClientRollup(t *testing.T) {
NewStRoot: big.NewInt(1), NewStRoot: big.NewInt(1),
NewExitRoot: big.NewInt(100), NewExitRoot: big.NewInt(100),
L1CoordinatorTxs: []*common.L1Tx{}, L1CoordinatorTxs: []*common.L1Tx{},
L2Txs: []*common.L2Tx{}, L2TxsData: []*common.L2Tx{},
FeeIdxCoordinator: make([]common.Idx, eth.FeeIdxCoordinatorLen), FeeIdxCoordinator: make([]common.Idx, eth.RollupConstFeeIdxCoordinatorLen),
VerifierIdx: 0, VerifierIdx: 0,
L1Batch: true, L1Batch: true,
}) })
@@ -201,8 +203,8 @@ func TestClientRollup(t *testing.T) {
NewStRoot: big.NewInt(1), NewStRoot: big.NewInt(1),
NewExitRoot: big.NewInt(100), NewExitRoot: big.NewInt(100),
L1CoordinatorTxs: []*common.L1Tx{}, L1CoordinatorTxs: []*common.L1Tx{},
L2Txs: []*common.L2Tx{}, L2TxsData: []*common.L2Tx{},
FeeIdxCoordinator: make([]common.Idx, eth.FeeIdxCoordinatorLen), FeeIdxCoordinator: make([]common.Idx, eth.RollupConstFeeIdxCoordinatorLen),
VerifierIdx: 0, VerifierIdx: 0,
L1Batch: true, L1Batch: true,
} }

10
test/historydb.go
View File

@@ -363,10 +363,10 @@ func GenCoordinators(nCoords int, blocks []common.Block) []common.Coordinator {
coords := []common.Coordinator{} coords := []common.Coordinator{}
for i := 0; i < nCoords; i++ { for i := 0; i < nCoords; i++ {
coords = append(coords, common.Coordinator{ coords = append(coords, common.Coordinator{
EthBlockNum: blocks[i%len(blocks)].EthBlockNum, EthBlockNum: blocks[i%len(blocks)].EthBlockNum,
Forger: ethCommon.BigToAddress(big.NewInt(int64(i))), Forger: ethCommon.BigToAddress(big.NewInt(int64(i))),
WithdrawAddr: ethCommon.BigToAddress(big.NewInt(int64(i))), Bidder: ethCommon.BigToAddress(big.NewInt(int64(i))),
URL: "https://foo.bar", URL: "https://foo.bar",
}) })
} }
return coords return coords
@@ -380,7 +380,7 @@ func GenBids(nBids int, blocks []common.Block, coords []common.Coordinator) []co
SlotNum: common.SlotNum(i), SlotNum: common.SlotNum(i),
BidValue: big.NewInt(int64(i)), BidValue: big.NewInt(int64(i)),
EthBlockNum: blocks[i%len(blocks)].EthBlockNum, EthBlockNum: blocks[i%len(blocks)].EthBlockNum,
ForgerAddr: coords[i%len(blocks)].Forger, Bidder: coords[i%len(blocks)].Bidder,
}) })
} }
return bids return bids