GenesisFromJSON is the config file for network_custom
Type: stringL1: root hash of the genesis block
L1: block number of the genesis block
L2: List of states contracts used to populate merkle tree at initial state
Chain ID of the L1 network
ZkEVMAddr Address of the L1 contract polygonZkEVMAddress
Must contain a minimum of 20 items
Must contain a maximum of 20 items
RollupManagerAddr Address of the L1 contract
Must contain a minimum of 20 items
Must contain a maximum of 20 items
PolAddr Address of the L1 Pol token Contract
Must contain a minimum of 20 items
Must contain a maximum of 20 items
GlobalExitRootManagerAddr Address of the L1 GlobalExitRootManager contract
Must contain a minimum of 20 items
Must contain a maximum of 20 items
GenesisFromJSON is the config file for network_custom
Type: stringL1: root hash of the genesis block
L1: block number of the genesis block
rollupManagerCreationBlockNumber is the block number where the RollupManager smc was deployed on L1 (0 auto-discover)
L2: List of states contracts used to populate merkle tree at initial state
Chain ID of the L1 network
ZkEVMAddr Address of the L1 contract polygonZkEVMAddress
Must contain a minimum of 20 items
Must contain a maximum of 20 items
RollupManagerAddr Address of the L1 contract
Must contain a minimum of 20 items
Must contain a maximum of 20 items
PolAddr Address of the L1 Pol token Contract
Must contain a minimum of 20 items
Must contain a maximum of 20 items
GlobalExitRootManagerAddr Address of the L1 GlobalExitRootManager contract
Must contain a minimum of 20 items
Must contain a maximum of 20 items
"300ms"
ChainID is the L2 ChainID provided by the Network Config
ForkID is the L2 ForkID provided by the Network Config
SenderAddress defines which private key the eth tx manager needs to use
to sign the L1 txs
CleanupLockedProofsInterval is the interval of time to clean up locked proofs.
"1m"
"300ms"
-GeneratingProofCleanupThreshold represents the time interval after
which a proof in generating state is considered to be stuck and
allowed to be cleared.
GasOffset is the amount of gas to be added to the gas estimation in order
to provide an amount that is higher than the estimated one. This is used
to avoid the TX getting reverted in case something has changed in the network
state after the estimation which can cause the TX to require more gas to be
executed.
ex:
gas estimation: 1000
gas offset: 100
final gas: 1100
UpgradeEtrogBatchNumber is the number of the first batch after upgrading to etrog
BatchProofL1BlockConfirmations is number of L1 blocks to consider we can generate the proof for a virtual batch
Chain ID of the L1 network
ZkEVMAddr Address of the L1 contract polygonZkEVMAddress
Must contain a minimum of 20 items
Must contain a maximum of 20 items
RollupManagerAddr Address of the L1 contract
Must contain a minimum of 20 items
Must contain a maximum of 20 items
PolAddr Address of the L1 Pol token Contract
Must contain a minimum of 20 items
Must contain a maximum of 20 items
GlobalExitRootManagerAddr Address of the L1 GlobalExitRootManager contract
Must contain a minimum of 20 items
Must contain a maximum of 20 items
BlockNumber is the block number where the polygonZKEVM smc was deployed on L1
Root hash of the genesis block
Must contain a minimum of 32 items
Must contain a maximum of 32 items
Actions is the data to populate into the state trie
DefaultGasPriceWei is used to set the gas price to be used by the default gas pricer or as minimim gas price by the follower gas pricer.
MaxGasPriceWei is used to limit the gas price returned by the follower gas pricer to a maximum value. It is ignored if 0.
"1m"
+GeneratingProofCleanupThreshold represents the time interval after
which a proof in generating state is considered to be stuck and
allowed to be cleared.
GasOffset is the amount of gas to be added to the gas estimation in order
to provide an amount that is higher than the estimated one. This is used
to avoid the TX getting reverted in case something has changed in the network
state after the estimation which can cause the TX to require more gas to be
executed.
ex:
gas estimation: 1000
gas offset: 100
final gas: 1100
UpgradeEtrogBatchNumber is the number of the first batch after upgrading to etrog
BatchProofL1BlockConfirmations is number of L1 blocks to consider we can generate the proof for a virtual batch
Chain ID of the L1 network
ZkEVMAddr Address of the L1 contract polygonZkEVMAddress
Must contain a minimum of 20 items
Must contain a maximum of 20 items
RollupManagerAddr Address of the L1 contract
Must contain a minimum of 20 items
Must contain a maximum of 20 items
PolAddr Address of the L1 Pol token Contract
Must contain a minimum of 20 items
Must contain a maximum of 20 items
GlobalExitRootManagerAddr Address of the L1 GlobalExitRootManager contract
Must contain a minimum of 20 items
Must contain a maximum of 20 items
BlockNumber is the block number where the polygonZKEVM smc was deployed on L1
Root hash of the genesis block
Must contain a minimum of 32 items
Must contain a maximum of 32 items
RollupManagerBlockNumber is the block number where the RollupManager smc was deployed on L1 if if set to AutoDiscoverRollupManagerBlockNumber(0) then is auto-discovered
Actions is the data to populate into the state trie
DefaultGasPriceWei is used to set the gas price to be used by the default gas pricer or as minimim gas price by the follower gas pricer.
MaxGasPriceWei is used to limit the gas price returned by the follower gas pricer to a maximum value. It is ignored if 0.
"1m"
"300ms"
"1m"
"300ms"
diff --git a/docs/config-file/node-config-doc.md b/docs/config-file/node-config-doc.md
index dc70d93791..965f3049b9 100644
--- a/docs/config-file/node-config-doc.md
+++ b/docs/config-file/node-config-doc.md
@@ -3306,11 +3306,12 @@ chainId=0
**Type:** : `object`
**Description:** L1: Genesis of the rollup, first block number and root
-| Property | Pattern | Type | Deprecated | Definition | Title/Description |
-| ---------------------------------------------------- | ------- | ---------------- | ---------- | ---------- | ----------------------------------------------------------------------------- |
-| - [BlockNumber](#NetworkConfig_Genesis_BlockNumber ) | No | integer | No | - | BlockNumber is the block number where the polygonZKEVM smc was deployed on L1 |
-| - [Root](#NetworkConfig_Genesis_Root ) | No | array of integer | No | - | Root hash of the genesis block |
-| - [Actions](#NetworkConfig_Genesis_Actions ) | No | array of object | No | - | Actions is the data to populate into the state trie |
+| Property | Pattern | Type | Deprecated | Definition | Title/Description |
+| ------------------------------------------------------------------------------ | ------- | ---------------- | ---------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| - [BlockNumber](#NetworkConfig_Genesis_BlockNumber ) | No | integer | No | - | BlockNumber is the block number where the polygonZKEVM smc was deployed on L1 |
+| - [Root](#NetworkConfig_Genesis_Root ) | No | array of integer | No | - | Root hash of the genesis block |
+| - [RollupManagerBlockNumber](#NetworkConfig_Genesis_RollupManagerBlockNumber ) | No | integer | No | - | RollupManagerBlockNumber is the block number where the RollupManager smc was deployed on L1 if if set to AutoDiscoverRollupManagerBlockNumber(0) then is auto-discovered |
+| - [Actions](#NetworkConfig_Genesis_Actions ) | No | array of object | No | - | Actions is the data to populate into the state trie |
#### 13.2.1. `NetworkConfig.Genesis.BlockNumber`
@@ -3331,7 +3332,21 @@ BlockNumber=0
**Type:** : `array of integer`
**Description:** Root hash of the genesis block
-#### 13.2.3. `NetworkConfig.Genesis.Actions`
+#### 13.2.3. `NetworkConfig.Genesis.RollupManagerBlockNumber`
+
+**Type:** : `integer`
+
+**Default:** `0`
+
+**Description:** RollupManagerBlockNumber is the block number where the RollupManager smc was deployed on L1 if if set to AutoDiscoverRollupManagerBlockNumber(0) then is auto-discovered
+
+**Example setting the default value** (0):
+```
+[NetworkConfig.Genesis]
+RollupManagerBlockNumber=0
+```
+
+#### 13.2.4. `NetworkConfig.Genesis.Actions`
**Type:** : `array of object`
**Description:** Actions is the data to populate into the state trie
@@ -3348,7 +3363,7 @@ BlockNumber=0
| ----------------------------------------------------- | ------------------------------------------------------------------------- |
| [Actions items](#NetworkConfig_Genesis_Actions_items) | GenesisAction represents one of the values set on the SMT during genesis. |
-##### 13.2.3.1. [NetworkConfig.Genesis.Actions.Actions items]
+##### 13.2.4.1. [NetworkConfig.Genesis.Actions.Actions items]
**Type:** : `object`
**Description:** GenesisAction represents one of the values set on the SMT during genesis.
@@ -3363,31 +3378,31 @@ BlockNumber=0
| - [value](#NetworkConfig_Genesis_Actions_items_value ) | No | string | No | - | - |
| - [root](#NetworkConfig_Genesis_Actions_items_root ) | No | string | No | - | - |
-##### 13.2.3.1.1. `NetworkConfig.Genesis.Actions.Actions items.address`
+##### 13.2.4.1.1. `NetworkConfig.Genesis.Actions.Actions items.address`
**Type:** : `string`
-##### 13.2.3.1.2. `NetworkConfig.Genesis.Actions.Actions items.type`
+##### 13.2.4.1.2. `NetworkConfig.Genesis.Actions.Actions items.type`
**Type:** : `integer`
-##### 13.2.3.1.3. `NetworkConfig.Genesis.Actions.Actions items.storagePosition`
+##### 13.2.4.1.3. `NetworkConfig.Genesis.Actions.Actions items.storagePosition`
**Type:** : `string`
-##### 13.2.3.1.4. `NetworkConfig.Genesis.Actions.Actions items.bytecode`
+##### 13.2.4.1.4. `NetworkConfig.Genesis.Actions.Actions items.bytecode`
**Type:** : `string`
-##### 13.2.3.1.5. `NetworkConfig.Genesis.Actions.Actions items.key`
+##### 13.2.4.1.5. `NetworkConfig.Genesis.Actions.Actions items.key`
**Type:** : `string`
-##### 13.2.3.1.6. `NetworkConfig.Genesis.Actions.Actions items.value`
+##### 13.2.4.1.6. `NetworkConfig.Genesis.Actions.Actions items.value`
**Type:** : `string`
-##### 13.2.3.1.7. `NetworkConfig.Genesis.Actions.Actions items.root`
+##### 13.2.4.1.7. `NetworkConfig.Genesis.Actions.Actions items.root`
**Type:** : `string`
diff --git a/docs/config-file/node-config-schema.json b/docs/config-file/node-config-schema.json
index 5b1b218cf5..9dd30962d2 100644
--- a/docs/config-file/node-config-schema.json
+++ b/docs/config-file/node-config-schema.json
@@ -1311,6 +1311,11 @@
"minItems": 32,
"description": "Root hash of the genesis block"
},
+ "RollupManagerBlockNumber": {
+ "type": "integer",
+ "description": "RollupManagerBlockNumber is the block number where the RollupManager smc was deployed on L1 if if set to AutoDiscoverRollupManagerBlockNumber(0) then is auto-discovered",
+ "default": 0
+ },
"Actions": {
"items": {
"properties": {
diff --git a/etherman/etherman.go b/etherman/etherman.go
index 6f609fccc1..18f1206505 100644
--- a/etherman/etherman.go
+++ b/etherman/etherman.go
@@ -339,6 +339,23 @@ func (etherMan *Client) VerifyGenBlockNumber(ctx context.Context, genBlockNumber
return true, nil
}
+// GetL1BlockUpgradeLxLy It returns the block genesis for LxLy before genesisBlock or error
+func (etherMan *Client) GetL1BlockUpgradeLxLy(ctx context.Context, genesisBlock uint64) (uint64, error) {
+ it, err := etherMan.GlobalExitRootManager.FilterUpdateL1InfoTree(&bind.FilterOpts{
+ Start: 1,
+ End: &genesisBlock,
+ Context: ctx,
+ }, nil, nil)
+ if err != nil {
+ return uint64(0), err
+ }
+ for it.Next() {
+ log.Debugf("BlockNumber: %d Topics:L1InfoTree", it.Event.Raw.BlockNumber)
+ return it.Event.Raw.BlockNumber, nil
+ }
+ return uint64(0), ErrNotFound
+}
+
// GetForks returns fork information
func (etherMan *Client) GetForks(ctx context.Context, genBlockNumber uint64, lastL1BlockSynced uint64) ([]state.ForkIDInterval, error) {
log.Debug("Getting forkIDs from blockNumber: ", genBlockNumber)
@@ -470,6 +487,25 @@ func (etherMan *Client) GetRollupInfoByBlockRange(ctx context.Context, fromBlock
return blocks, blocksOrder, nil
}
+// GetRollupInfoByBlockRangePreviousRollupGenesis function retrieves the Rollup information that are included in all this ethereum blocks
+// but it only retrieves the information from the previous rollup genesis block to the current block.
+func (etherMan *Client) GetRollupInfoByBlockRangePreviousRollupGenesis(ctx context.Context, fromBlock uint64, toBlock *uint64) ([]Block, map[common.Hash][]Order, error) {
+ // Filter query
+ query := ethereum.FilterQuery{
+ FromBlock: new(big.Int).SetUint64(fromBlock),
+ Addresses: []common.Address{etherMan.l1Cfg.GlobalExitRootManagerAddr},
+ Topics: [][]common.Hash{{updateL1InfoTreeSignatureHash}},
+ }
+ if toBlock != nil {
+ query.ToBlock = new(big.Int).SetUint64(*toBlock)
+ }
+ blocks, blocksOrder, err := etherMan.readEvents(ctx, query)
+ if err != nil {
+ return nil, nil, err
+ }
+ return blocks, blocksOrder, nil
+}
+
// Order contains the event order to let the synchronizer store the information following this order.
type Order struct {
Name EventOrder
diff --git a/state/block.go b/state/block.go
index 7883770249..8b91425bb3 100644
--- a/state/block.go
+++ b/state/block.go
@@ -1,6 +1,7 @@
package state
import (
+ "fmt"
"time"
"github.com/ethereum/go-ethereum/common"
@@ -15,6 +16,10 @@ type Block struct {
Checked bool
}
+func (b *Block) String() string {
+ return fmt.Sprintf("BlockNumber: %d, BlockHash: %s, ParentHash: %s, ReceivedAt: %s", b.BlockNumber, b.BlockHash, b.ParentHash, b.ReceivedAt)
+}
+
// NewBlock creates a block with the given data.
func NewBlock(blockNumber uint64) *Block {
return &Block{BlockNumber: blockNumber}
diff --git a/state/genesis.go b/state/genesis.go
index 50c4b5a950..726c0739e9 100644
--- a/state/genesis.go
+++ b/state/genesis.go
@@ -17,12 +17,19 @@ import (
"github.com/jackc/pgx/v4"
)
+const (
+ // AutoDiscoverRollupManagerBlockNumber is the value to auto-discover the RollupManager creation block number
+ AutoDiscoverRollupManagerBlockNumber = uint64(0)
+)
+
// Genesis contains the information to populate state on creation
type Genesis struct {
// BlockNumber is the block number where the polygonZKEVM smc was deployed on L1
BlockNumber uint64
// Root hash of the genesis block
Root common.Hash
+ // RollupManagerBlockNumber is the block number where the RollupManager smc was deployed on L1 if if set to AutoDiscoverRollupManagerBlockNumber(0) then is auto-discovered
+ RollupManagerBlockNumber uint64
// Actions is the data to populate into the state trie
Actions []*GenesisAction
}
diff --git a/synchronizer/common/syncinterfaces/etherman.go b/synchronizer/common/syncinterfaces/etherman.go
index fdbdd669f8..44717746df 100644
--- a/synchronizer/common/syncinterfaces/etherman.go
+++ b/synchronizer/common/syncinterfaces/etherman.go
@@ -20,8 +20,14 @@ type EthermanFullInterface interface {
EthermanGetLatestBatchNumber
GetFinalizedBlockNumber(ctx context.Context) (uint64, error)
+ EthermanPreRollup
}
type EthermanGetLatestBatchNumber interface {
GetLatestBatchNumber() (uint64, error)
}
+
+type EthermanPreRollup interface {
+ GetL1BlockUpgradeLxLy(ctx context.Context, genesisBlock uint64) (uint64, error)
+ GetRollupInfoByBlockRangePreviousRollupGenesis(ctx context.Context, fromBlock uint64, toBlock *uint64) ([]etherman.Block, map[common.Hash][]etherman.Order, error)
+}
diff --git a/synchronizer/common/syncinterfaces/mocks/etherman_full_interface.go b/synchronizer/common/syncinterfaces/mocks/etherman_full_interface.go
index a904419575..c6e99c36ac 100644
--- a/synchronizer/common/syncinterfaces/mocks/etherman_full_interface.go
+++ b/synchronizer/common/syncinterfaces/mocks/etherman_full_interface.go
@@ -143,6 +143,63 @@ func (_c *EthermanFullInterface_GetFinalizedBlockNumber_Call) RunAndReturn(run f
return _c
}
+// GetL1BlockUpgradeLxLy provides a mock function with given fields: ctx, genesisBlock
+func (_m *EthermanFullInterface) GetL1BlockUpgradeLxLy(ctx context.Context, genesisBlock uint64) (uint64, error) {
+ ret := _m.Called(ctx, genesisBlock)
+
+ if len(ret) == 0 {
+ panic("no return value specified for GetL1BlockUpgradeLxLy")
+ }
+
+ var r0 uint64
+ var r1 error
+ if rf, ok := ret.Get(0).(func(context.Context, uint64) (uint64, error)); ok {
+ return rf(ctx, genesisBlock)
+ }
+ if rf, ok := ret.Get(0).(func(context.Context, uint64) uint64); ok {
+ r0 = rf(ctx, genesisBlock)
+ } else {
+ r0 = ret.Get(0).(uint64)
+ }
+
+ if rf, ok := ret.Get(1).(func(context.Context, uint64) error); ok {
+ r1 = rf(ctx, genesisBlock)
+ } else {
+ r1 = ret.Error(1)
+ }
+
+ return r0, r1
+}
+
+// EthermanFullInterface_GetL1BlockUpgradeLxLy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetL1BlockUpgradeLxLy'
+type EthermanFullInterface_GetL1BlockUpgradeLxLy_Call struct {
+ *mock.Call
+}
+
+// GetL1BlockUpgradeLxLy is a helper method to define mock.On call
+// - ctx context.Context
+// - genesisBlock uint64
+func (_e *EthermanFullInterface_Expecter) GetL1BlockUpgradeLxLy(ctx interface{}, genesisBlock interface{}) *EthermanFullInterface_GetL1BlockUpgradeLxLy_Call {
+ return &EthermanFullInterface_GetL1BlockUpgradeLxLy_Call{Call: _e.mock.On("GetL1BlockUpgradeLxLy", ctx, genesisBlock)}
+}
+
+func (_c *EthermanFullInterface_GetL1BlockUpgradeLxLy_Call) Run(run func(ctx context.Context, genesisBlock uint64)) *EthermanFullInterface_GetL1BlockUpgradeLxLy_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(context.Context), args[1].(uint64))
+ })
+ return _c
+}
+
+func (_c *EthermanFullInterface_GetL1BlockUpgradeLxLy_Call) Return(_a0 uint64, _a1 error) *EthermanFullInterface_GetL1BlockUpgradeLxLy_Call {
+ _c.Call.Return(_a0, _a1)
+ return _c
+}
+
+func (_c *EthermanFullInterface_GetL1BlockUpgradeLxLy_Call) RunAndReturn(run func(context.Context, uint64) (uint64, error)) *EthermanFullInterface_GetL1BlockUpgradeLxLy_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
// GetLatestBatchNumber provides a mock function with given fields:
func (_m *EthermanFullInterface) GetLatestBatchNumber() (uint64, error) {
ret := _m.Called()
@@ -322,6 +379,75 @@ func (_c *EthermanFullInterface_GetRollupInfoByBlockRange_Call) RunAndReturn(run
return _c
}
+// GetRollupInfoByBlockRangePreviousRollupGenesis provides a mock function with given fields: ctx, fromBlock, toBlock
+func (_m *EthermanFullInterface) GetRollupInfoByBlockRangePreviousRollupGenesis(ctx context.Context, fromBlock uint64, toBlock *uint64) ([]etherman.Block, map[common.Hash][]etherman.Order, error) {
+ ret := _m.Called(ctx, fromBlock, toBlock)
+
+ if len(ret) == 0 {
+ panic("no return value specified for GetRollupInfoByBlockRangePreviousRollupGenesis")
+ }
+
+ var r0 []etherman.Block
+ var r1 map[common.Hash][]etherman.Order
+ var r2 error
+ if rf, ok := ret.Get(0).(func(context.Context, uint64, *uint64) ([]etherman.Block, map[common.Hash][]etherman.Order, error)); ok {
+ return rf(ctx, fromBlock, toBlock)
+ }
+ if rf, ok := ret.Get(0).(func(context.Context, uint64, *uint64) []etherman.Block); ok {
+ r0 = rf(ctx, fromBlock, toBlock)
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).([]etherman.Block)
+ }
+ }
+
+ if rf, ok := ret.Get(1).(func(context.Context, uint64, *uint64) map[common.Hash][]etherman.Order); ok {
+ r1 = rf(ctx, fromBlock, toBlock)
+ } else {
+ if ret.Get(1) != nil {
+ r1 = ret.Get(1).(map[common.Hash][]etherman.Order)
+ }
+ }
+
+ if rf, ok := ret.Get(2).(func(context.Context, uint64, *uint64) error); ok {
+ r2 = rf(ctx, fromBlock, toBlock)
+ } else {
+ r2 = ret.Error(2)
+ }
+
+ return r0, r1, r2
+}
+
+// EthermanFullInterface_GetRollupInfoByBlockRangePreviousRollupGenesis_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRollupInfoByBlockRangePreviousRollupGenesis'
+type EthermanFullInterface_GetRollupInfoByBlockRangePreviousRollupGenesis_Call struct {
+ *mock.Call
+}
+
+// GetRollupInfoByBlockRangePreviousRollupGenesis is a helper method to define mock.On call
+// - ctx context.Context
+// - fromBlock uint64
+// - toBlock *uint64
+func (_e *EthermanFullInterface_Expecter) GetRollupInfoByBlockRangePreviousRollupGenesis(ctx interface{}, fromBlock interface{}, toBlock interface{}) *EthermanFullInterface_GetRollupInfoByBlockRangePreviousRollupGenesis_Call {
+ return &EthermanFullInterface_GetRollupInfoByBlockRangePreviousRollupGenesis_Call{Call: _e.mock.On("GetRollupInfoByBlockRangePreviousRollupGenesis", ctx, fromBlock, toBlock)}
+}
+
+func (_c *EthermanFullInterface_GetRollupInfoByBlockRangePreviousRollupGenesis_Call) Run(run func(ctx context.Context, fromBlock uint64, toBlock *uint64)) *EthermanFullInterface_GetRollupInfoByBlockRangePreviousRollupGenesis_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(context.Context), args[1].(uint64), args[2].(*uint64))
+ })
+ return _c
+}
+
+func (_c *EthermanFullInterface_GetRollupInfoByBlockRangePreviousRollupGenesis_Call) Return(_a0 []etherman.Block, _a1 map[common.Hash][]etherman.Order, _a2 error) *EthermanFullInterface_GetRollupInfoByBlockRangePreviousRollupGenesis_Call {
+ _c.Call.Return(_a0, _a1, _a2)
+ return _c
+}
+
+func (_c *EthermanFullInterface_GetRollupInfoByBlockRangePreviousRollupGenesis_Call) RunAndReturn(run func(context.Context, uint64, *uint64) ([]etherman.Block, map[common.Hash][]etherman.Order, error)) *EthermanFullInterface_GetRollupInfoByBlockRangePreviousRollupGenesis_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
// GetTrustedSequencerURL provides a mock function with given fields:
func (_m *EthermanFullInterface) GetTrustedSequencerURL() (string, error) {
ret := _m.Called()
diff --git a/synchronizer/common/syncinterfaces/mocks/etherman_pre_rollup.go b/synchronizer/common/syncinterfaces/mocks/etherman_pre_rollup.go
new file mode 100644
index 0000000000..3599152aee
--- /dev/null
+++ b/synchronizer/common/syncinterfaces/mocks/etherman_pre_rollup.go
@@ -0,0 +1,166 @@
+// Code generated by mockery. DO NOT EDIT.
+
+package mock_syncinterfaces
+
+import (
+ context "context"
+
+ common "github.com/ethereum/go-ethereum/common"
+
+ etherman "github.com/0xPolygonHermez/zkevm-node/etherman"
+
+ mock "github.com/stretchr/testify/mock"
+)
+
+// EthermanPreRollup is an autogenerated mock type for the EthermanPreRollup type
+type EthermanPreRollup struct {
+ mock.Mock
+}
+
+type EthermanPreRollup_Expecter struct {
+ mock *mock.Mock
+}
+
+func (_m *EthermanPreRollup) EXPECT() *EthermanPreRollup_Expecter {
+ return &EthermanPreRollup_Expecter{mock: &_m.Mock}
+}
+
+// GetL1BlockUpgradeLxLy provides a mock function with given fields: ctx, genesisBlock
+func (_m *EthermanPreRollup) GetL1BlockUpgradeLxLy(ctx context.Context, genesisBlock uint64) (uint64, error) {
+ ret := _m.Called(ctx, genesisBlock)
+
+ if len(ret) == 0 {
+ panic("no return value specified for GetL1BlockUpgradeLxLy")
+ }
+
+ var r0 uint64
+ var r1 error
+ if rf, ok := ret.Get(0).(func(context.Context, uint64) (uint64, error)); ok {
+ return rf(ctx, genesisBlock)
+ }
+ if rf, ok := ret.Get(0).(func(context.Context, uint64) uint64); ok {
+ r0 = rf(ctx, genesisBlock)
+ } else {
+ r0 = ret.Get(0).(uint64)
+ }
+
+ if rf, ok := ret.Get(1).(func(context.Context, uint64) error); ok {
+ r1 = rf(ctx, genesisBlock)
+ } else {
+ r1 = ret.Error(1)
+ }
+
+ return r0, r1
+}
+
+// EthermanPreRollup_GetL1BlockUpgradeLxLy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetL1BlockUpgradeLxLy'
+type EthermanPreRollup_GetL1BlockUpgradeLxLy_Call struct {
+ *mock.Call
+}
+
+// GetL1BlockUpgradeLxLy is a helper method to define mock.On call
+// - ctx context.Context
+// - genesisBlock uint64
+func (_e *EthermanPreRollup_Expecter) GetL1BlockUpgradeLxLy(ctx interface{}, genesisBlock interface{}) *EthermanPreRollup_GetL1BlockUpgradeLxLy_Call {
+ return &EthermanPreRollup_GetL1BlockUpgradeLxLy_Call{Call: _e.mock.On("GetL1BlockUpgradeLxLy", ctx, genesisBlock)}
+}
+
+func (_c *EthermanPreRollup_GetL1BlockUpgradeLxLy_Call) Run(run func(ctx context.Context, genesisBlock uint64)) *EthermanPreRollup_GetL1BlockUpgradeLxLy_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(context.Context), args[1].(uint64))
+ })
+ return _c
+}
+
+func (_c *EthermanPreRollup_GetL1BlockUpgradeLxLy_Call) Return(_a0 uint64, _a1 error) *EthermanPreRollup_GetL1BlockUpgradeLxLy_Call {
+ _c.Call.Return(_a0, _a1)
+ return _c
+}
+
+func (_c *EthermanPreRollup_GetL1BlockUpgradeLxLy_Call) RunAndReturn(run func(context.Context, uint64) (uint64, error)) *EthermanPreRollup_GetL1BlockUpgradeLxLy_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// GetRollupInfoByBlockRangePreviousRollupGenesis provides a mock function with given fields: ctx, fromBlock, toBlock
+func (_m *EthermanPreRollup) GetRollupInfoByBlockRangePreviousRollupGenesis(ctx context.Context, fromBlock uint64, toBlock *uint64) ([]etherman.Block, map[common.Hash][]etherman.Order, error) {
+ ret := _m.Called(ctx, fromBlock, toBlock)
+
+ if len(ret) == 0 {
+ panic("no return value specified for GetRollupInfoByBlockRangePreviousRollupGenesis")
+ }
+
+ var r0 []etherman.Block
+ var r1 map[common.Hash][]etherman.Order
+ var r2 error
+ if rf, ok := ret.Get(0).(func(context.Context, uint64, *uint64) ([]etherman.Block, map[common.Hash][]etherman.Order, error)); ok {
+ return rf(ctx, fromBlock, toBlock)
+ }
+ if rf, ok := ret.Get(0).(func(context.Context, uint64, *uint64) []etherman.Block); ok {
+ r0 = rf(ctx, fromBlock, toBlock)
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).([]etherman.Block)
+ }
+ }
+
+ if rf, ok := ret.Get(1).(func(context.Context, uint64, *uint64) map[common.Hash][]etherman.Order); ok {
+ r1 = rf(ctx, fromBlock, toBlock)
+ } else {
+ if ret.Get(1) != nil {
+ r1 = ret.Get(1).(map[common.Hash][]etherman.Order)
+ }
+ }
+
+ if rf, ok := ret.Get(2).(func(context.Context, uint64, *uint64) error); ok {
+ r2 = rf(ctx, fromBlock, toBlock)
+ } else {
+ r2 = ret.Error(2)
+ }
+
+ return r0, r1, r2
+}
+
+// EthermanPreRollup_GetRollupInfoByBlockRangePreviousRollupGenesis_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRollupInfoByBlockRangePreviousRollupGenesis'
+type EthermanPreRollup_GetRollupInfoByBlockRangePreviousRollupGenesis_Call struct {
+ *mock.Call
+}
+
+// GetRollupInfoByBlockRangePreviousRollupGenesis is a helper method to define mock.On call
+// - ctx context.Context
+// - fromBlock uint64
+// - toBlock *uint64
+func (_e *EthermanPreRollup_Expecter) GetRollupInfoByBlockRangePreviousRollupGenesis(ctx interface{}, fromBlock interface{}, toBlock interface{}) *EthermanPreRollup_GetRollupInfoByBlockRangePreviousRollupGenesis_Call {
+ return &EthermanPreRollup_GetRollupInfoByBlockRangePreviousRollupGenesis_Call{Call: _e.mock.On("GetRollupInfoByBlockRangePreviousRollupGenesis", ctx, fromBlock, toBlock)}
+}
+
+func (_c *EthermanPreRollup_GetRollupInfoByBlockRangePreviousRollupGenesis_Call) Run(run func(ctx context.Context, fromBlock uint64, toBlock *uint64)) *EthermanPreRollup_GetRollupInfoByBlockRangePreviousRollupGenesis_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run(args[0].(context.Context), args[1].(uint64), args[2].(*uint64))
+ })
+ return _c
+}
+
+func (_c *EthermanPreRollup_GetRollupInfoByBlockRangePreviousRollupGenesis_Call) Return(_a0 []etherman.Block, _a1 map[common.Hash][]etherman.Order, _a2 error) *EthermanPreRollup_GetRollupInfoByBlockRangePreviousRollupGenesis_Call {
+ _c.Call.Return(_a0, _a1, _a2)
+ return _c
+}
+
+func (_c *EthermanPreRollup_GetRollupInfoByBlockRangePreviousRollupGenesis_Call) RunAndReturn(run func(context.Context, uint64, *uint64) ([]etherman.Block, map[common.Hash][]etherman.Order, error)) *EthermanPreRollup_GetRollupInfoByBlockRangePreviousRollupGenesis_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
+// NewEthermanPreRollup creates a new instance of EthermanPreRollup. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewEthermanPreRollup(t interface {
+ mock.TestingT
+ Cleanup(func())
+}) *EthermanPreRollup {
+ mock := &EthermanPreRollup{}
+ mock.Mock.Test(t)
+
+ t.Cleanup(func() { mock.AssertExpectations(t) })
+
+ return mock
+}
diff --git a/synchronizer/l1_parallel_sync/l1_data_message.go b/synchronizer/l1_parallel_sync/l1_data_message.go
index b84b4299cd..83fdb958d7 100644
--- a/synchronizer/l1_parallel_sync/l1_data_message.go
+++ b/synchronizer/l1_parallel_sync/l1_data_message.go
@@ -65,12 +65,12 @@ func newL1SyncMessageControlWProducerIsFullySynced(lastBlock uint64) *L1SyncMess
}
func newL1SyncMessageData(result *rollupInfoByBlockRangeResult) *L1SyncMessage {
- if result == nil {
+ if result == nil { //nolint:all
log.Fatal("newL1PackageDataFromResult: result is nil, the idea of this func is create packages with data")
}
return &L1SyncMessage{
dataIsValid: true,
- data: *result,
+ data: *result, //nolint:all
ctrlIsValid: false,
}
}
diff --git a/synchronizer/synchronizer.go b/synchronizer/synchronizer.go
index 75c3c3cefc..074912e419 100644
--- a/synchronizer/synchronizer.go
+++ b/synchronizer/synchronizer.go
@@ -33,6 +33,7 @@ const (
// SequentialMode is the value for L1SynchronizationMode to run in sequential mode
SequentialMode = "sequential"
maxBatchNumber = ^uint64(0)
+ maxBlockNumber = ^uint64(0)
timeOfLiveBatchOnCache = 5 * time.Minute
)
@@ -278,6 +279,163 @@ func rollback(ctx context.Context, dbTx pgx.Tx, err error) error {
return err
}
+func (s *ClientSynchronizer) isGenesisProcessed(ctx context.Context, dbTx pgx.Tx) (bool, *state.Block, error) {
+ lastEthBlockSynced, err := s.state.GetLastBlock(ctx, dbTx)
+ if err != nil && errors.Is(err, state.ErrStateNotSynchronized) {
+ return false, lastEthBlockSynced, nil
+ }
+
+ if lastEthBlockSynced.BlockNumber >= s.genesis.BlockNumber {
+ log.Infof("Genesis block processed. Last block synced: %d >= genesis %d", lastEthBlockSynced.BlockNumber, s.genesis.BlockNumber)
+ return true, lastEthBlockSynced, nil
+ }
+ log.Warnf("Genesis block not processed yet. Last block synced: %d < genesis %d", lastEthBlockSynced.BlockNumber, s.genesis.BlockNumber)
+ return false, lastEthBlockSynced, nil
+}
+
+// getStartingL1Block find if need to update and if yes the starting point:
+// bool -> need to process blocks
+// uint64 -> first block to synchronize
+// error -> error
+// 1. Check last synced block on DB, if there are any could be fully synced (>=genesis) or syncing pre-genesis events (= genesisBlockNumber {
+ log.Infof("sync pregenesis: rollupManagerBlockNumber>=genesisBlockNumber (%d>=%d). Nothing in pregenesis", rollupManagerBlockNumber, genesisBlockNumber)
+ return false, 0, nil
+ }
+ log.Infof("sync pregenesis: No block on DB, starting from LxLy upgrade block (rollupManagerBlockNumber) %d", upgradeLxLyBlockNumber)
+ return true, upgradeLxLyBlockNumber, nil
+ } else if err != nil {
+ log.Errorf("Error getting last Block on DB err:%v", err)
+ return false, 0, err
+ }
+ if lastBlock.BlockNumber >= genesisBlockNumber-1 {
+ log.Warnf("sync pregenesis: Last block processed is %d, which is greater or equal than the previous genesis block %d", lastBlock, genesisBlockNumber)
+ return false, 0, nil
+ }
+ log.Infof("sync pregenesis: Continue processing pre-genesis blocks, last block processed on DB is %d", lastBlock.BlockNumber+1)
+ return true, lastBlock.BlockNumber + 1, nil
+}
+
+func (s *ClientSynchronizer) synchronizePreGenesisRollupEvents(syncChunkSize uint64, ctx context.Context) error {
+ // Sync events from RollupManager that happen before rollup creation
+ startTime := time.Now()
+ log.Info("synchronizing events from RollupManager that happen before rollup creation")
+ rollupManagerBlockNumber := s.genesis.RollupManagerBlockNumber
+ needToUpdate, fromBlock, err := s.getStartingL1Block(ctx, s.genesis.BlockNumber, rollupManagerBlockNumber, nil)
+ if err != nil {
+ log.Errorf("sync pregenesis: error getting starting L1 block. Error: %v", err)
+ return err
+ }
+ if !needToUpdate {
+ log.Infof("sync pregenesis: No need to process blocks before the genesis block %d", s.genesis.BlockNumber)
+ return nil
+ }
+ toBlockFinal := s.genesis.BlockNumber - 1
+ log.Infof("sync pregenesis: starting syncing pre genesis LxLy events from block %d to block %d (total %d blocks) chunk size %d",
+ fromBlock, toBlockFinal, toBlockFinal-fromBlock+1, syncChunkSize)
+ for i := fromBlock; true; i += syncChunkSize {
+ toBlock := min(i+syncChunkSize-1, toBlockFinal)
+ log.Debugf("sync pregenesis: syncing L1InfoTree from blocks [%d - %d] remains: %d", i, toBlock, toBlockFinal-toBlock)
+ blocks, order, err := s.etherMan.GetRollupInfoByBlockRangePreviousRollupGenesis(s.ctx, i, &toBlock)
+ if err != nil {
+ log.Error("sync pregenesis: error getting rollupInfoByBlockRange before rollup genesis: ", err)
+ return err
+ }
+ log.Debugf("sync pregenesis: syncing L1InfoTree from blocks [%d - %d] -> num_block:%d num_order:%d", i, toBlock, len(blocks), len(order))
+ err = s.ProcessBlockRange(blocks, order)
+ if err != nil {
+ log.Error("sync pregenesis: error processing blocks before the genesis: ", err)
+ return err
+ }
+ if toBlock == toBlockFinal {
+ break
+ }
+ }
+ elapsedTime := time.Since(startTime)
+ log.Infof("sync pregenesis: sync L1InfoTree finish: from %d to %d total_block %d done in %s", fromBlock, toBlockFinal, toBlockFinal-fromBlock+1, &elapsedTime)
+ return nil
+}
+
+func (s *ClientSynchronizer) processGenesis() (*state.Block, error) {
+ log.Info("State is empty, verifying genesis block")
+ valid, err := s.etherMan.VerifyGenBlockNumber(s.ctx, s.genesis.BlockNumber)
+ if err != nil {
+ log.Error("error checking genesis block number. Error: ", err)
+ return nil, err
+ } else if !valid {
+ log.Error("genesis Block number configured is not valid. It is required the block number where the PolygonZkEVM smc was deployed")
+ return nil, fmt.Errorf("genesis Block number configured is not valid. It is required the block number where the PolygonZkEVM smc was deployed")
+ }
+ err = s.synchronizePreGenesisRollupEvents(s.cfg.SyncChunkSize, s.ctx)
+ if err != nil {
+ log.Error("error synchronizing pre genesis events: ", err)
+ return nil, err
+ }
+
+ header, err := s.etherMan.HeaderByNumber(s.ctx, big.NewInt(0).SetUint64(s.genesis.BlockNumber))
+ if err != nil {
+ log.Errorf("error getting l1 block header for block %d. Error: %v", s.genesis.BlockNumber, err)
+ return nil, err
+ }
+ log.Info("synchronizing rollup creation block")
+ lastEthBlockSynced := &state.Block{
+ BlockNumber: header.Number.Uint64(),
+ BlockHash: header.Hash(),
+ ParentHash: header.ParentHash,
+ ReceivedAt: time.Unix(int64(header.Time), 0),
+ }
+ dbTx, err := s.state.BeginStateTransaction(s.ctx)
+ if err != nil {
+ log.Errorf("error creating db transaction to get latest block. Error: %v", err)
+ return nil, err
+ }
+ // This add the genesis block and set values on tree
+ genesisRoot, err := s.state.SetGenesis(s.ctx, *lastEthBlockSynced, s.genesis, stateMetrics.SynchronizerCallerLabel, dbTx)
+ if err != nil {
+ log.Error("error setting genesis: ", err)
+ return nil, rollback(s.ctx, dbTx, err)
+ }
+ err = s.RequestAndProcessRollupGenesisBlock(dbTx, lastEthBlockSynced)
+ if err != nil {
+ log.Error("error processing Rollup genesis block: ", err)
+ return nil, rollback(s.ctx, dbTx, err)
+ }
+
+ if genesisRoot != s.genesis.Root {
+ log.Errorf("Calculated newRoot should be %s instead of %s", s.genesis.Root.String(), genesisRoot.String())
+ return nil, rollback(s.ctx, dbTx, fmt.Errorf("calculated newRoot should be %s instead of %s", s.genesis.Root.String(), genesisRoot.String()))
+ }
+ // Waiting for the flushID to be stored
+ err = s.checkFlushID(dbTx)
+ if err != nil {
+ log.Error("error checking genesis flushID: ", err)
+ return nil, rollback(s.ctx, dbTx, err)
+ }
+ if err := dbTx.Commit(s.ctx); err != nil {
+ log.Errorf("error genesis committing dbTx, err: %v", err)
+ return nil, rollback(s.ctx, dbTx, err)
+ }
+ log.Info("Genesis root matches! Stored genesis blocks.")
+ return lastEthBlockSynced, nil
+}
+
// Sync function will read the last state synced and will continue from that point.
// Sync() will read blockchain events to detect rollup updates
func (s *ClientSynchronizer) Sync() error {
@@ -288,68 +446,24 @@ func (s *ClientSynchronizer) Sync() error {
if s.asyncL1BlockChecker != nil {
_ = s.asyncL1BlockChecker.OnStart(s.ctx)
}
-
- dbTx, err := s.state.BeginStateTransaction(s.ctx)
+ genesisDone, lastEthBlockSynced, err := s.isGenesisProcessed(s.ctx, nil)
if err != nil {
- log.Errorf("error creating db transaction to get latest block. Error: %v", err)
+ log.Errorf("error checking if genesis is processed. Error: %v", err)
return err
}
- lastEthBlockSynced, err := s.state.GetLastBlock(s.ctx, dbTx)
- if err != nil {
- if errors.Is(err, state.ErrStateNotSynchronized) {
- log.Info("State is empty, verifying genesis block")
- valid, err := s.etherMan.VerifyGenBlockNumber(s.ctx, s.genesis.BlockNumber)
- if err != nil {
- log.Error("error checking genesis block number. Error: ", err)
- return rollback(s.ctx, dbTx, err)
- } else if !valid {
- log.Error("genesis Block number configured is not valid. It is required the block number where the PolygonZkEVM smc was deployed")
- return rollback(s.ctx, dbTx, fmt.Errorf("genesis Block number configured is not valid. It is required the block number where the PolygonZkEVM smc was deployed"))
- }
- log.Info("Setting genesis block")
- header, err := s.etherMan.HeaderByNumber(s.ctx, big.NewInt(0).SetUint64(s.genesis.BlockNumber))
- if err != nil {
- log.Errorf("error getting l1 block header for block %d. Error: %v", s.genesis.BlockNumber, err)
- return rollback(s.ctx, dbTx, err)
- }
- lastEthBlockSynced = &state.Block{
- BlockNumber: header.Number.Uint64(),
- BlockHash: header.Hash(),
- ParentHash: header.ParentHash,
- ReceivedAt: time.Unix(int64(header.Time), 0),
- }
- genesisRoot, err := s.state.SetGenesis(s.ctx, *lastEthBlockSynced, s.genesis, stateMetrics.SynchronizerCallerLabel, dbTx)
- if err != nil {
- log.Error("error setting genesis: ", err)
- return rollback(s.ctx, dbTx, err)
- }
- err = s.RequestAndProcessRollupGenesisBlock(dbTx, lastEthBlockSynced)
- if err != nil {
- log.Error("error processing Rollup genesis block: ", err)
- return rollback(s.ctx, dbTx, err)
- }
-
- if genesisRoot != s.genesis.Root {
- log.Errorf("Calculated newRoot should be %s instead of %s", s.genesis.Root.String(), genesisRoot.String())
- return rollback(s.ctx, dbTx, fmt.Errorf("calculated newRoot should be %s instead of %s", s.genesis.Root.String(), genesisRoot.String()))
- }
- // Waiting for the flushID to be stored
- err = s.checkFlushID(dbTx)
- if err != nil {
- log.Error("error checking genesis flushID: ", err)
- return rollback(s.ctx, dbTx, err)
- }
- log.Debug("Genesis root matches!")
- } else {
- log.Error("unexpected error getting the latest ethereum block. Error: ", err)
- rollbackErr := dbTx.Rollback(s.ctx)
- if rollbackErr != nil {
- log.Errorf("error rolling back state. RollbackErr: %v, err: %s", rollbackErr, err.Error())
- return rollbackErr
- }
+ if !genesisDone {
+ lastEthBlockSynced, err = s.processGenesis()
+ if err != nil {
+ log.Errorf("error processing genesis. Error: %v", err)
return err
}
}
+ dbTx, err := s.state.BeginStateTransaction(s.ctx)
+ if err != nil {
+ log.Errorf("error creating db transaction to get latest block. Error: %v", err)
+ return err
+ }
+
initBatchNumber, err := s.state.GetLastBatchNumber(s.ctx, dbTx)
if err != nil {
log.Error("error getting latest batchNumber synced. Error: ", err)
@@ -520,40 +634,36 @@ func (s *ClientSynchronizer) RequestAndProcessRollupGenesisBlock(dbTx pgx.Tx, la
log.Error("error getting rollupInfoByBlockRange after set the genesis: ", err)
return err
}
- // Check that the response is the expected. It should be 1 block with 2 orders
+ // Check that the response is the expected. It should be 1 block with ForkID event
+ log.Debugf("SanityCheck for genesis block (%d) events: %+v", lastEthBlockSynced.BlockNumber, order)
err = sanityCheckForGenesisBlockRollupInfo(blocks, order)
if err != nil {
return err
}
- forkId := s.state.GetForkIDByBlockNumber(blocks[0].BlockNumber)
- err = s.l1EventProcessors.Process(s.ctx, actions.ForkIdType(forkId), etherman.Order{Name: etherman.ForkIDsOrder, Pos: 0}, &blocks[0], dbTx)
+ log.Infof("Processing genesis block %d orders: %+v", lastEthBlockSynced.BlockNumber, order)
+ err = s.internalProcessBlock(maxBlockNumber, blocks[0], order[blocks[0].BlockHash], false, dbTx)
if err != nil {
- log.Error("error storing genesis forkID: ", err)
- return err
- }
- if len(blocks[0].SequencedBatches) != 0 {
- batchSequence := l1event_orders.GetSequenceFromL1EventOrder(etherman.InitialSequenceBatchesOrder, &blocks[0], 0)
- forkId = s.state.GetForkIDByBatchNumber(batchSequence.FromBatchNumber)
- err = s.l1EventProcessors.Process(s.ctx, actions.ForkIdType(forkId), etherman.Order{Name: etherman.InitialSequenceBatchesOrder, Pos: 0}, &blocks[0], dbTx)
- if err != nil {
- log.Error("error storing initial tx (batch 1): ", err)
- return err
- }
+ log.Errorf("error processinge events on genesis block %d: err:%w", lastEthBlockSynced.BlockNumber, err)
}
+
return nil
}
func sanityCheckForGenesisBlockRollupInfo(blocks []etherman.Block, order map[common.Hash][]etherman.Order) error {
if len(blocks) != 1 || len(order) < 1 || len(order[blocks[0].BlockHash]) < 1 {
- log.Errorf("error getting rollupInfoByBlockRange after set the genesis. Expected 1 block with 2 orders")
- return fmt.Errorf("error getting rollupInfoByBlockRange after set the genesis. Expected 1 block with 2 orders")
+ log.Errorf("error getting rollupInfoByBlockRange after set the genesis. Expected 1 block with minimum 2 orders")
+ return fmt.Errorf("error getting rollupInfoByBlockRange after set the genesis. Expected 1 block with minimum 2 orders")
}
- if order[blocks[0].BlockHash][0].Name != etherman.ForkIDsOrder {
- log.Errorf("error getting rollupInfoByBlockRange after set the genesis. Expected ForkIDsOrder, got %s", order[blocks[0].BlockHash][0].Name)
- return fmt.Errorf("error getting rollupInfoByBlockRange after set the genesis. Expected ForkIDsOrder")
+ // The genesis block implies 1 ForkID event
+ for _, value := range order[blocks[0].BlockHash] {
+ if value.Name == etherman.ForkIDsOrder {
+ return nil
+ }
}
-
- return nil
+ err := fmt.Errorf("events on genesis block (%d) need a ForkIDsOrder event but this block got %+v",
+ blocks[0].BlockNumber, order[blocks[0].BlockHash])
+ log.Error(err.Error())
+ return err
}
// This function syncs the node from a specific block to the latest
@@ -700,67 +810,20 @@ func (s *ClientSynchronizer) ProcessBlockRange(blocks []etherman.Block, order ma
log.Errorf("error creating db transaction to store block. BlockNumber: %d, error: %v", blocks[i].BlockNumber, err)
return err
}
- b := state.Block{
- BlockNumber: blocks[i].BlockNumber,
- BlockHash: blocks[i].BlockHash,
- ParentHash: blocks[i].ParentHash,
- ReceivedAt: blocks[i].ReceivedAt,
- }
- if blocks[i].BlockNumber <= finalizedBlockNumber {
- b.Checked = true
- }
- // Add block information
- err = s.state.AddBlock(s.ctx, &b, dbTx)
+ err = s.internalProcessBlock(finalizedBlockNumber, blocks[i], order[blocks[i].BlockHash], true, dbTx)
if err != nil {
+ log.Error("rollingback BlockNumber: %d, because error internalProcessBlock: ", blocks[i].BlockNumber, err)
// If any goes wrong we ensure that the state is rollbacked
- log.Errorf("error storing block. BlockNumber: %d, error: %v", blocks[i].BlockNumber, err)
rollbackErr := dbTx.Rollback(s.ctx)
- if rollbackErr != nil {
- log.Errorf("error rolling back state to store block. BlockNumber: %d, rollbackErr: %s, error : %v", blocks[i].BlockNumber, rollbackErr.Error(), err)
- return rollbackErr
+ if rollbackErr != nil && !errors.Is(rollbackErr, pgx.ErrTxClosed) {
+ log.Warnf("error rolling back state to store block. BlockNumber: %d, rollbackErr: %s, error : %v", blocks[i].BlockNumber, rollbackErr.Error(), err)
+ return fmt.Errorf("error rollback BlockNumber: %d: err:%w original error:%w", blocks[i].BlockNumber, rollbackErr, err)
}
return err
}
- for _, element := range order[blocks[i].BlockHash] {
- batchSequence := l1event_orders.GetSequenceFromL1EventOrder(element.Name, &blocks[i], element.Pos)
- var forkId uint64
- if batchSequence != nil {
- forkId = s.state.GetForkIDByBatchNumber(batchSequence.FromBatchNumber)
- log.Debug("EventOrder: ", element.Name, ". Batch Sequence: ", batchSequence, "forkId: ", forkId)
- } else {
- forkId = s.state.GetForkIDByBlockNumber(blocks[i].BlockNumber)
- log.Debug("EventOrder: ", element.Name, ". BlockNumber: ", blocks[i].BlockNumber, ". forkId: ", forkId)
- }
- forkIdTyped := actions.ForkIdType(forkId)
- // Process event received from l1
- err := s.l1EventProcessors.Process(s.ctx, forkIdTyped, element, &blocks[i], dbTx)
- if err != nil {
- log.Error("error: ", err)
- // If any goes wrong we ensure that the state is rollbacked
- rollbackErr := dbTx.Rollback(s.ctx)
- if rollbackErr != nil && !errors.Is(rollbackErr, pgx.ErrTxClosed) {
- log.Warnf("error rolling back state to store block. BlockNumber: %d, rollbackErr: %s, error : %v", blocks[i].BlockNumber, rollbackErr.Error(), err)
- return rollbackErr
- }
- return err
- }
- }
- log.Debug("Checking FlushID to commit L1 data to db")
- err = s.checkFlushID(dbTx)
- if err != nil {
- // If any goes wrong we ensure that the state is rollbacked
- log.Errorf("error checking flushID. Error: %v", err)
- rollbackErr := dbTx.Rollback(s.ctx)
- if rollbackErr != nil {
- log.Errorf("error rolling back state. RollbackErr: %s, Error : %v", rollbackErr.Error(), err)
- return rollbackErr
- }
- return err
- }
err = dbTx.Commit(s.ctx)
if err != nil {
- // If any goes wrong we ensure that the state is rollbacked
log.Errorf("error committing state to store block. BlockNumber: %d, err: %v", blocks[i].BlockNumber, err)
rollbackErr := dbTx.Rollback(s.ctx)
if rollbackErr != nil {
@@ -773,6 +836,57 @@ func (s *ClientSynchronizer) ProcessBlockRange(blocks []etherman.Block, order ma
return nil
}
+// internalProcessBlock process one iteration of events and stores the information in the db
+func (s *ClientSynchronizer) internalProcessBlock(finalizedBlockNumber uint64, blocks etherman.Block, order []etherman.Order, addBlock bool, dbTx pgx.Tx) error {
+ var err error
+ // New info has to be included into the db using the state
+ if addBlock {
+ b := state.Block{
+ BlockNumber: blocks.BlockNumber,
+ BlockHash: blocks.BlockHash,
+ ParentHash: blocks.ParentHash,
+ ReceivedAt: blocks.ReceivedAt,
+ }
+ if blocks.BlockNumber <= finalizedBlockNumber {
+ b.Checked = true
+ }
+ // Add block information
+ log.Debugf("Storing block. Block: %s", b.String())
+ err = s.state.AddBlock(s.ctx, &b, dbTx)
+ if err != nil {
+ log.Errorf("error storing block. BlockNumber: %d, error: %v", blocks.BlockNumber, err)
+ return err
+ }
+ }
+
+ for _, element := range order {
+ batchSequence := l1event_orders.GetSequenceFromL1EventOrder(element.Name, &blocks, element.Pos)
+ var forkId uint64
+ if batchSequence != nil {
+ forkId = s.state.GetForkIDByBatchNumber(batchSequence.FromBatchNumber)
+ log.Debug("EventOrder: ", element.Name, ". Batch Sequence: ", batchSequence, "forkId: ", forkId)
+ } else {
+ forkId = s.state.GetForkIDByBlockNumber(blocks.BlockNumber)
+ log.Debug("EventOrder: ", element.Name, ". BlockNumber: ", blocks.BlockNumber, "forkId: ", forkId)
+ }
+ forkIdTyped := actions.ForkIdType(forkId)
+ // Process event received from l1
+ err := s.l1EventProcessors.Process(s.ctx, forkIdTyped, element, &blocks, dbTx)
+ if err != nil {
+ log.Error("1EventProcessors.Process error: ", err)
+ return err
+ }
+ }
+ log.Debug("Checking FlushID to commit L1 data to db")
+ err = s.checkFlushID(dbTx)
+ if err != nil {
+ log.Errorf("error checking flushID. Error: %v", err)
+ return err
+ }
+
+ return nil
+}
+
func (s *ClientSynchronizer) syncTrustedState(latestSyncedBatch uint64) error {
if s.syncTrustedStateExecutor == nil {
return nil
diff --git a/synchronizer/synchronizer_test.go b/synchronizer/synchronizer_test.go
index ce0c27e280..8337948c8f 100644
--- a/synchronizer/synchronizer_test.go
+++ b/synchronizer/synchronizer_test.go
@@ -2,6 +2,7 @@ package synchronizer
import (
context "context"
+ "fmt"
"math"
"math/big"
"testing"
@@ -45,6 +46,40 @@ type mocks struct {
//EventLog *eventLogMock
}
+func TestGetStartingL1BlockAutodiscover(t *testing.T) {
+ genesis, cfg, m := setupGenericTest(t)
+ ethermanForL1 := []syncinterfaces.EthermanFullInterface{m.Etherman}
+ syncInterface, err := NewSynchronizer(false, m.Etherman, ethermanForL1, m.State, m.Pool, m.EthTxManager, m.ZKEVMClient, m.zkEVMClientEthereumCompatible, nil, *genesis, *cfg, false)
+ require.NoError(t, err)
+ sync, ok := syncInterface.(*ClientSynchronizer)
+ require.True(t, ok)
+ ctx := context.TODO()
+ t.Run("getStartingL1Block autodiscover OK", func(t *testing.T) {
+ m.State.EXPECT().GetLastBlock(ctx, nil).Return(nil, state.ErrStateNotSynchronized).Once()
+ m.Etherman.EXPECT().GetL1BlockUpgradeLxLy(mock.Anything, mock.Anything).Return(uint64(100), nil).Once()
+ needProcess, firstBlock, err := sync.getStartingL1Block(ctx, 123, 0, nil)
+ require.NoError(t, err)
+ require.True(t, needProcess)
+ require.Equal(t, uint64(100), firstBlock)
+ })
+
+ t.Run("getStartingL1Block autodiscover Fails", func(t *testing.T) {
+ m.State.EXPECT().GetLastBlock(ctx, nil).Return(nil, state.ErrStateNotSynchronized).Once()
+ m.Etherman.EXPECT().GetL1BlockUpgradeLxLy(mock.Anything, mock.Anything).Return(uint64(0), fmt.Errorf("error")).Once()
+ _, _, err = sync.getStartingL1Block(ctx, 123, 0, nil)
+ require.Error(t, err)
+ })
+
+ t.Run("getStartingL1Block have already started sync", func(t *testing.T) {
+ m.State.EXPECT().GetLastBlock(ctx, nil).Return(&state.Block{BlockNumber: 100}, nil).Once()
+
+ needProcess, firstBlock, err := sync.getStartingL1Block(ctx, 123, 0, nil)
+ require.NoError(t, err)
+ require.True(t, needProcess)
+ require.Equal(t, uint64(101), firstBlock)
+ })
+}
+
// Feature #2220 and #2239: Optimize Trusted state synchronization
//
// this Check partially point 2: Use previous batch stored in memory to avoid getting from database
@@ -123,7 +158,7 @@ func TestGivenPermissionlessNodeWhenSyncronizeFirstTimeABatchThenStoreItInALocal
// but it used a feature that is not implemented in new one that is asking beyond the last block on L1
func TestForcedBatchEtrog(t *testing.T) {
genesis := state.Genesis{
- BlockNumber: uint64(123456),
+ BlockNumber: uint64(0),
}
cfg := Config{
SyncInterval: cfgTypes.Duration{Duration: 1 * time.Second},
@@ -156,15 +191,22 @@ func TestForcedBatchEtrog(t *testing.T) {
ToBatchNumber: ^uint64(0),
}
m.State.EXPECT().GetForkIDInMemory(uint64(7)).Return(&forkIdInterval)
+ parentHash := common.HexToHash("0x111")
+ ethHeader := ðTypes.Header{Number: big.NewInt(1), ParentHash: parentHash}
+ ethBlock := ethTypes.NewBlockWithHeader(ethHeader)
+ lastBlock := &state.Block{BlockHash: ethBlock.Hash(), BlockNumber: ethBlock.Number().Uint64(), ParentHash: ethBlock.ParentHash()}
+ m.State.
+ On("GetLastBlock", mock.Anything, nil).
+ Return(lastBlock, nil).
+ Once()
m.State.
On("BeginStateTransaction", ctxMatchBy).
Run(func(args mock.Arguments) {
ctx := args[0].(context.Context)
- parentHash := common.HexToHash("0x111")
- ethHeader0 := ðTypes.Header{Number: big.NewInt(0), ParentHash: parentHash}
+ ethHeader0 := ðTypes.Header{Number: big.NewInt(1), ParentHash: parentHash}
ethBlock0 := ethTypes.NewBlockWithHeader(ethHeader0)
- ethHeader1 := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash()}
+ ethHeader1 := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock0.Hash()}
ethBlock1 := ethTypes.NewBlockWithHeader(ethHeader1)
lastBlock0 := &state.Block{BlockHash: ethBlock0.Hash(), BlockNumber: ethBlock0.Number().Uint64(), ParentHash: ethBlock0.ParentHash()}
lastBlock1 := &state.Block{BlockHash: ethBlock1.Hash(), BlockNumber: ethBlock1.Number().Uint64(), ParentHash: ethBlock1.ParentHash()}
@@ -173,10 +215,6 @@ func TestForcedBatchEtrog(t *testing.T) {
On("GetForkIDByBatchNumber", mock.Anything).
Return(uint64(7), nil).
Maybe()
- m.State.
- On("GetLastBlock", ctx, m.DbTx).
- Return(lastBlock0, nil).
- Once()
m.State.
On("GetLastBatchNumber", ctx, m.DbTx).
@@ -246,13 +284,15 @@ func TestForcedBatchEtrog(t *testing.T) {
}}
ethermanBlock0 := etherman.Block{
- BlockNumber: 0,
+ BlockNumber: ethBlock0.NumberU64(),
ReceivedAt: t,
+ ParentHash: ethBlock0.ParentHash(),
BlockHash: ethBlock0.Hash(),
}
ethermanBlock1 := etherman.Block{
- BlockNumber: 1,
+ BlockNumber: ethBlock0.NumberU64(),
ReceivedAt: t,
+ ParentHash: ethBlock1.ParentHash(),
BlockHash: ethBlock1.Hash(),
SequencedBatches: [][]etherman.SequencedBatch{{sequencedBatch}},
ForcedBatches: forceb,
@@ -401,7 +441,7 @@ func TestForcedBatchEtrog(t *testing.T) {
// but it used a feature that is not implemented in new one that is asking beyond the last block on L1
func TestSequenceForcedBatchIncaberry(t *testing.T) {
genesis := state.Genesis{
- BlockNumber: uint64(123456),
+ BlockNumber: uint64(0),
}
cfg := Config{
SyncInterval: cfgTypes.Duration{Duration: 1 * time.Second},
@@ -423,27 +463,28 @@ func TestSequenceForcedBatchIncaberry(t *testing.T) {
// state preparation
ctxMatchBy := mock.MatchedBy(func(ctx context.Context) bool { return ctx != nil })
+ parentHash := common.HexToHash("0x111")
+ ethHeader0 := ðTypes.Header{Number: big.NewInt(1), ParentHash: parentHash}
+ ethBlock0 := ethTypes.NewBlockWithHeader(ethHeader0)
+ ethHeader1 := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock0.Hash()}
+ ethBlock1 := ethTypes.NewBlockWithHeader(ethHeader1)
+ lastBlock0 := &state.Block{BlockHash: ethBlock0.Hash(), BlockNumber: ethBlock0.Number().Uint64(), ParentHash: ethBlock0.ParentHash()}
+ lastBlock1 := &state.Block{BlockHash: ethBlock1.Hash(), BlockNumber: ethBlock1.Number().Uint64(), ParentHash: ethBlock1.ParentHash()}
+
+ m.State.
+ On("GetLastBlock", mock.Anything, nil).
+ Return(lastBlock0, nil).
+ Once()
+
m.State.
On("BeginStateTransaction", ctxMatchBy).
Run(func(args mock.Arguments) {
ctx := args[0].(context.Context)
- parentHash := common.HexToHash("0x111")
- ethHeader0 := ðTypes.Header{Number: big.NewInt(0), ParentHash: parentHash}
- ethBlock0 := ethTypes.NewBlockWithHeader(ethHeader0)
- ethHeader1 := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash()}
- ethBlock1 := ethTypes.NewBlockWithHeader(ethHeader1)
- lastBlock0 := &state.Block{BlockHash: ethBlock0.Hash(), BlockNumber: ethBlock0.Number().Uint64(), ParentHash: ethBlock0.ParentHash()}
- lastBlock1 := &state.Block{BlockHash: ethBlock1.Hash(), BlockNumber: ethBlock1.Number().Uint64(), ParentHash: ethBlock1.ParentHash()}
m.State.
On("GetForkIDByBatchNumber", mock.Anything).
Return(uint64(1), nil).
Maybe()
- m.State.
- On("GetLastBlock", ctx, m.DbTx).
- Return(lastBlock0, nil).
- Once()
-
m.State.
On("GetLastBatchNumber", ctx, m.DbTx).
Return(uint64(10), nil).
@@ -517,7 +558,7 @@ func TestSequenceForcedBatchIncaberry(t *testing.T) {
ParentHash: ethBlock0.ParentHash(),
}
ethermanBlock1 := etherman.Block{
- BlockNumber: ethBlock1.NumberU64(),
+ BlockNumber: ethBlock0.NumberU64(),
BlockHash: ethBlock1.Hash(),
ParentHash: ethBlock1.ParentHash(),
SequencedForceBatches: [][]etherman.SequencedForceBatch{{sequencedForceBatch}},
@@ -965,38 +1006,39 @@ func TestReorg(t *testing.T) {
ToBatchNumber: math.MaxUint64,
}
m.State.EXPECT().GetForkIDInMemory(uint64(9)).Return(&forkIdInterval)
+ parentHash := common.HexToHash("0x111")
+ ethHeader0 := ðTypes.Header{Number: big.NewInt(0), ParentHash: parentHash}
+ ethBlock0 := ethTypes.NewBlockWithHeader(ethHeader0)
+ ethHeader1bis := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash(), Time: 10, GasUsed: 20, Root: common.HexToHash("0x234")}
+ ethBlock1bis := ethTypes.NewBlockWithHeader(ethHeader1bis)
+ ethHeader2bis := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock1bis.Hash()}
+ ethBlock2bis := ethTypes.NewBlockWithHeader(ethHeader2bis)
+ ethHeader3bis := ðTypes.Header{Number: big.NewInt(3), ParentHash: ethBlock2bis.Hash()}
+ ethBlock3bis := ethTypes.NewBlockWithHeader(ethHeader3bis)
+ ethHeader1 := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash()}
+ ethBlock1 := ethTypes.NewBlockWithHeader(ethHeader1)
+ ethHeader2 := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock1.Hash()}
+ ethBlock2 := ethTypes.NewBlockWithHeader(ethHeader2)
+ ethHeader3 := ðTypes.Header{Number: big.NewInt(3), ParentHash: ethBlock2.Hash()}
+ ethBlock3 := ethTypes.NewBlockWithHeader(ethHeader3)
+
+ lastBlock0 := &state.Block{BlockHash: ethBlock0.Hash(), BlockNumber: ethBlock0.Number().Uint64(), ParentHash: ethBlock0.ParentHash()}
+ lastBlock1 := &state.Block{BlockHash: ethBlock1.Hash(), BlockNumber: ethBlock1.Number().Uint64(), ParentHash: ethBlock1.ParentHash()}
+
+ m.State.
+ On("GetLastBlock", mock.Anything, nil).
+ Return(lastBlock1, nil).
+ Once()
m.State.
On("BeginStateTransaction", ctxMatchBy).
Run(func(args mock.Arguments) {
ctx := args[0].(context.Context)
- parentHash := common.HexToHash("0x111")
- ethHeader0 := ðTypes.Header{Number: big.NewInt(0), ParentHash: parentHash}
- ethBlock0 := ethTypes.NewBlockWithHeader(ethHeader0)
- ethHeader1bis := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash(), Time: 10, GasUsed: 20, Root: common.HexToHash("0x234")}
- ethBlock1bis := ethTypes.NewBlockWithHeader(ethHeader1bis)
- ethHeader2bis := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock1bis.Hash()}
- ethBlock2bis := ethTypes.NewBlockWithHeader(ethHeader2bis)
- ethHeader3bis := ðTypes.Header{Number: big.NewInt(3), ParentHash: ethBlock2bis.Hash()}
- ethBlock3bis := ethTypes.NewBlockWithHeader(ethHeader3bis)
- ethHeader1 := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash()}
- ethBlock1 := ethTypes.NewBlockWithHeader(ethHeader1)
- ethHeader2 := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock1.Hash()}
- ethBlock2 := ethTypes.NewBlockWithHeader(ethHeader2)
- ethHeader3 := ðTypes.Header{Number: big.NewInt(3), ParentHash: ethBlock2.Hash()}
- ethBlock3 := ethTypes.NewBlockWithHeader(ethHeader3)
-
- lastBlock0 := &state.Block{BlockHash: ethBlock0.Hash(), BlockNumber: ethBlock0.Number().Uint64(), ParentHash: ethBlock0.ParentHash()}
- lastBlock1 := &state.Block{BlockHash: ethBlock1.Hash(), BlockNumber: ethBlock1.Number().Uint64(), ParentHash: ethBlock1.ParentHash()}
m.State.
On("GetForkIDByBatchNumber", mock.Anything).
Return(uint64(9), nil).
Maybe()
- m.State.
- On("GetLastBlock", ctx, m.DbTx).
- Return(lastBlock1, nil).
- Once()
m.State.
On("GetLastBatchNumber", ctx, m.DbTx).
@@ -1288,33 +1330,31 @@ func TestLatestSyncedBlockEmpty(t *testing.T) {
ToBatchNumber: math.MaxUint64,
}
m.State.EXPECT().GetForkIDInMemory(uint64(9)).Return(&forkIdInterval)
+ parentHash := common.HexToHash("0x111")
+ ethHeader0 := ðTypes.Header{Number: big.NewInt(0), ParentHash: parentHash}
+ ethBlock0 := ethTypes.NewBlockWithHeader(ethHeader0)
+ ethHeader1 := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash()}
+ ethBlock1 := ethTypes.NewBlockWithHeader(ethHeader1)
+ ethHeader2 := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock1.Hash()}
+ ethBlock2 := ethTypes.NewBlockWithHeader(ethHeader2)
+ ethHeader3 := ðTypes.Header{Number: big.NewInt(3), ParentHash: ethBlock2.Hash()}
+ ethBlock3 := ethTypes.NewBlockWithHeader(ethHeader3)
+
+ lastBlock0 := &state.Block{BlockHash: ethBlock0.Hash(), BlockNumber: ethBlock0.Number().Uint64(), ParentHash: ethBlock0.ParentHash()}
+ lastBlock1 := &state.Block{BlockHash: ethBlock1.Hash(), BlockNumber: ethBlock1.Number().Uint64(), ParentHash: ethBlock1.ParentHash()}
+ m.State.
+ On("GetLastBlock", mock.Anything, nil).
+ Return(lastBlock1, nil).
+ Once()
m.State.
On("BeginStateTransaction", ctxMatchBy).
Run(func(args mock.Arguments) {
ctx := args[0].(context.Context)
- parentHash := common.HexToHash("0x111")
- ethHeader0 := ðTypes.Header{Number: big.NewInt(0), ParentHash: parentHash}
- ethBlock0 := ethTypes.NewBlockWithHeader(ethHeader0)
- ethHeader1 := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash()}
- ethBlock1 := ethTypes.NewBlockWithHeader(ethHeader1)
- ethHeader2 := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock1.Hash()}
- ethBlock2 := ethTypes.NewBlockWithHeader(ethHeader2)
- ethHeader3 := ðTypes.Header{Number: big.NewInt(3), ParentHash: ethBlock2.Hash()}
- ethBlock3 := ethTypes.NewBlockWithHeader(ethHeader3)
-
- lastBlock0 := &state.Block{BlockHash: ethBlock0.Hash(), BlockNumber: ethBlock0.Number().Uint64(), ParentHash: ethBlock0.ParentHash()}
- lastBlock1 := &state.Block{BlockHash: ethBlock1.Hash(), BlockNumber: ethBlock1.Number().Uint64(), ParentHash: ethBlock1.ParentHash()}
-
m.State.
On("GetForkIDByBatchNumber", mock.Anything).
Return(uint64(9), nil).
Maybe()
- m.State.
- On("GetLastBlock", ctx, m.DbTx).
- Return(lastBlock1, nil).
- Once()
-
m.State.
On("GetLastBatchNumber", ctx, m.DbTx).
Return(uint64(10), nil).
@@ -1505,34 +1545,33 @@ func TestRegularReorg(t *testing.T) {
ToBatchNumber: math.MaxUint64,
}
m.State.EXPECT().GetForkIDInMemory(uint64(9)).Return(&forkIdInterval)
+ parentHash := common.HexToHash("0x111")
+ ethHeader0 := ðTypes.Header{Number: big.NewInt(0), ParentHash: parentHash}
+ ethBlock0 := ethTypes.NewBlockWithHeader(ethHeader0)
+ ethHeader1bis := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash(), Time: 10, GasUsed: 20, Root: common.HexToHash("0x234")}
+ ethBlock1bis := ethTypes.NewBlockWithHeader(ethHeader1bis)
+ ethHeader2bis := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock1bis.Hash()}
+ ethBlock2bis := ethTypes.NewBlockWithHeader(ethHeader2bis)
+ ethHeader1 := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash()}
+ ethBlock1 := ethTypes.NewBlockWithHeader(ethHeader1)
+ ethHeader2 := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock1.Hash()}
+ ethBlock2 := ethTypes.NewBlockWithHeader(ethHeader2)
+
+ lastBlock0 := &state.Block{BlockHash: ethBlock0.Hash(), BlockNumber: ethBlock0.Number().Uint64(), ParentHash: ethBlock0.ParentHash()}
+ lastBlock1 := &state.Block{BlockHash: ethBlock1.Hash(), BlockNumber: ethBlock1.Number().Uint64(), ParentHash: ethBlock1.ParentHash()}
+ m.State.
+ On("GetLastBlock", mock.Anything, nil).
+ Return(lastBlock1, nil).
+ Once()
m.State.
On("BeginStateTransaction", ctxMatchBy).
Run(func(args mock.Arguments) {
ctx := args[0].(context.Context)
- parentHash := common.HexToHash("0x111")
- ethHeader0 := ðTypes.Header{Number: big.NewInt(0), ParentHash: parentHash}
- ethBlock0 := ethTypes.NewBlockWithHeader(ethHeader0)
- ethHeader1bis := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash(), Time: 10, GasUsed: 20, Root: common.HexToHash("0x234")}
- ethBlock1bis := ethTypes.NewBlockWithHeader(ethHeader1bis)
- ethHeader2bis := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock1bis.Hash()}
- ethBlock2bis := ethTypes.NewBlockWithHeader(ethHeader2bis)
- ethHeader1 := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash()}
- ethBlock1 := ethTypes.NewBlockWithHeader(ethHeader1)
- ethHeader2 := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock1.Hash()}
- ethBlock2 := ethTypes.NewBlockWithHeader(ethHeader2)
-
- lastBlock0 := &state.Block{BlockHash: ethBlock0.Hash(), BlockNumber: ethBlock0.Number().Uint64(), ParentHash: ethBlock0.ParentHash()}
- lastBlock1 := &state.Block{BlockHash: ethBlock1.Hash(), BlockNumber: ethBlock1.Number().Uint64(), ParentHash: ethBlock1.ParentHash()}
-
m.State.
On("GetForkIDByBatchNumber", mock.Anything).
Return(uint64(9), nil).
Maybe()
- m.State.
- On("GetLastBlock", ctx, m.DbTx).
- Return(lastBlock1, nil).
- Once()
// After a ResetState get lastblock that must be block 0
m.State.
@@ -1790,36 +1829,35 @@ func TestLatestSyncedBlockEmptyWithExtraReorg(t *testing.T) {
ToBatchNumber: math.MaxUint64,
}
m.State.EXPECT().GetForkIDInMemory(uint64(9)).Return(&forkIdInterval)
+ parentHash := common.HexToHash("0x111")
+ ethHeader0 := ðTypes.Header{Number: big.NewInt(0), ParentHash: parentHash}
+ ethBlock0 := ethTypes.NewBlockWithHeader(ethHeader0)
+ ethHeader1 := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash()}
+ ethBlock1 := ethTypes.NewBlockWithHeader(ethHeader1)
+ ethHeader1bis := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash(), Time: 0, GasUsed: 10}
+ ethBlock1bis := ethTypes.NewBlockWithHeader(ethHeader1bis)
+ ethHeader2 := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock1.Hash()}
+ ethBlock2 := ethTypes.NewBlockWithHeader(ethHeader2)
+ ethHeader3 := ðTypes.Header{Number: big.NewInt(3), ParentHash: ethBlock2.Hash()}
+ ethBlock3 := ethTypes.NewBlockWithHeader(ethHeader3)
+
+ lastBlock0 := &state.Block{BlockHash: ethBlock0.Hash(), BlockNumber: ethBlock0.Number().Uint64(), ParentHash: ethBlock0.ParentHash()}
+ lastBlock1 := &state.Block{BlockHash: ethBlock1.Hash(), BlockNumber: ethBlock1.Number().Uint64(), ParentHash: ethBlock1.ParentHash()}
+ lastBlock2 := &state.Block{BlockHash: ethBlock2.Hash(), BlockNumber: ethBlock2.Number().Uint64(), ParentHash: ethBlock2.ParentHash()}
+ m.State.
+ On("GetLastBlock", mock.Anything, nil).
+ Return(lastBlock2, nil).
+ Once()
m.State.
On("BeginStateTransaction", ctxMatchBy).
Run(func(args mock.Arguments) {
ctx := args[0].(context.Context)
- parentHash := common.HexToHash("0x111")
- ethHeader0 := ðTypes.Header{Number: big.NewInt(0), ParentHash: parentHash}
- ethBlock0 := ethTypes.NewBlockWithHeader(ethHeader0)
- ethHeader1 := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash()}
- ethBlock1 := ethTypes.NewBlockWithHeader(ethHeader1)
- ethHeader1bis := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash(), Time: 0, GasUsed: 10}
- ethBlock1bis := ethTypes.NewBlockWithHeader(ethHeader1bis)
- ethHeader2 := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock1.Hash()}
- ethBlock2 := ethTypes.NewBlockWithHeader(ethHeader2)
- ethHeader3 := ðTypes.Header{Number: big.NewInt(3), ParentHash: ethBlock2.Hash()}
- ethBlock3 := ethTypes.NewBlockWithHeader(ethHeader3)
-
- lastBlock0 := &state.Block{BlockHash: ethBlock0.Hash(), BlockNumber: ethBlock0.Number().Uint64(), ParentHash: ethBlock0.ParentHash()}
- lastBlock1 := &state.Block{BlockHash: ethBlock1.Hash(), BlockNumber: ethBlock1.Number().Uint64(), ParentHash: ethBlock1.ParentHash()}
- lastBlock2 := &state.Block{BlockHash: ethBlock2.Hash(), BlockNumber: ethBlock2.Number().Uint64(), ParentHash: ethBlock2.ParentHash()}
m.State.
On("GetForkIDByBatchNumber", mock.Anything).
Return(uint64(9), nil).
Maybe()
- m.State.
- On("GetLastBlock", ctx, m.DbTx).
- Return(lastBlock2, nil).
- Once()
-
m.State.
On("GetLastBatchNumber", ctx, m.DbTx).
Return(uint64(10), nil).
@@ -1971,13 +2009,13 @@ func TestLatestSyncedBlockEmptyWithExtraReorg(t *testing.T) {
Once()
ethermanBlock0 := etherman.Block{
- BlockNumber: 0,
+ BlockNumber: ethBlock0.NumberU64(),
ReceivedAt: ti,
BlockHash: ethBlock0.Hash(),
ParentHash: ethBlock0.ParentHash(),
}
ethermanBlock1bis := etherman.Block{
- BlockNumber: 1,
+ BlockNumber: ethBlock1.NumberU64(),
ReceivedAt: ti,
BlockHash: ethBlock1.Hash(),
ParentHash: ethBlock1.ParentHash(),
@@ -2069,35 +2107,33 @@ func TestCallFromEmptyBlockAndReorg(t *testing.T) {
ToBatchNumber: math.MaxUint64,
}
m.State.EXPECT().GetForkIDInMemory(uint64(9)).Return(&forkIdInterval)
-
+ parentHash := common.HexToHash("0x111")
+ ethHeader0 := ðTypes.Header{Number: big.NewInt(0), ParentHash: parentHash}
+ ethBlock0 := ethTypes.NewBlockWithHeader(ethHeader0)
+ ethHeader1bis := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash(), Time: 10, GasUsed: 20, Root: common.HexToHash("0x234")}
+ ethBlock1bis := ethTypes.NewBlockWithHeader(ethHeader1bis)
+ ethHeader2bis := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock1bis.Hash()}
+ ethBlock2bis := ethTypes.NewBlockWithHeader(ethHeader2bis)
+ ethHeader1 := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash()}
+ ethBlock1 := ethTypes.NewBlockWithHeader(ethHeader1)
+ ethHeader2 := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock1.Hash()}
+ ethBlock2 := ethTypes.NewBlockWithHeader(ethHeader2)
+
+ lastBlock0 := &state.Block{BlockHash: ethBlock0.Hash(), BlockNumber: ethBlock0.Number().Uint64(), ParentHash: ethBlock0.ParentHash()}
+ lastBlock1 := &state.Block{BlockHash: ethBlock1.Hash(), BlockNumber: ethBlock1.Number().Uint64(), ParentHash: ethBlock1.ParentHash()}
+ m.State.
+ On("GetLastBlock", mock.Anything, nil).
+ Return(lastBlock1, nil).
+ Once()
m.State.
On("BeginStateTransaction", ctxMatchBy).
Run(func(args mock.Arguments) {
ctx := args[0].(context.Context)
- parentHash := common.HexToHash("0x111")
- ethHeader0 := ðTypes.Header{Number: big.NewInt(0), ParentHash: parentHash}
- ethBlock0 := ethTypes.NewBlockWithHeader(ethHeader0)
- ethHeader1bis := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash(), Time: 10, GasUsed: 20, Root: common.HexToHash("0x234")}
- ethBlock1bis := ethTypes.NewBlockWithHeader(ethHeader1bis)
- ethHeader2bis := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock1bis.Hash()}
- ethBlock2bis := ethTypes.NewBlockWithHeader(ethHeader2bis)
- ethHeader1 := ðTypes.Header{Number: big.NewInt(1), ParentHash: ethBlock0.Hash()}
- ethBlock1 := ethTypes.NewBlockWithHeader(ethHeader1)
- ethHeader2 := ðTypes.Header{Number: big.NewInt(2), ParentHash: ethBlock1.Hash()}
- ethBlock2 := ethTypes.NewBlockWithHeader(ethHeader2)
-
- lastBlock0 := &state.Block{BlockHash: ethBlock0.Hash(), BlockNumber: ethBlock0.Number().Uint64(), ParentHash: ethBlock0.ParentHash()}
- lastBlock1 := &state.Block{BlockHash: ethBlock1.Hash(), BlockNumber: ethBlock1.Number().Uint64(), ParentHash: ethBlock1.ParentHash()}
m.State.
On("GetForkIDByBatchNumber", mock.Anything).
Return(uint64(9), nil).
Maybe()
- m.State.
- On("GetLastBlock", ctx, m.DbTx).
- Return(lastBlock1, nil).
- Once()
-
m.State.
On("GetLastBatchNumber", ctx, m.DbTx).
Return(uint64(10), nil).