From 697a629137a9cec5166b52b339f212fef6515eea Mon Sep 17 00:00:00 2001 From: Manav Darji Date: Thu, 1 Jun 2023 15:14:28 +0530 Subject: [PATCH] calculate last state ID from incoming state object with eth call --- consensus/bor/api/caller.go | 2 + consensus/bor/api/caller_mock.go | 16 +++++++ consensus/bor/bor.go | 32 ++++++++----- consensus/bor/contract/client.go | 10 +++-- consensus/bor/genesis.go | 3 +- consensus/bor/genesis_contract_mock.go | 9 ++-- consensus/bor/span_mock.go | 34 +++++++------- graphql/graphql.go | 5 ++- internal/ethapi/api.go | 62 +++++++++++++++++++++++--- params/config.go | 18 +++----- tests/bor/bor_test.go | 4 +- 11 files changed, 136 insertions(+), 59 deletions(-) diff --git a/consensus/bor/api/caller.go b/consensus/bor/api/caller.go index d5fe259c97..49c06b3f73 100644 --- a/consensus/bor/api/caller.go +++ b/consensus/bor/api/caller.go @@ -4,6 +4,7 @@ import ( "context" "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/internal/ethapi" "github.com/ethereum/go-ethereum/rpc" ) @@ -11,4 +12,5 @@ import ( //go:generate mockgen -destination=./caller_mock.go -package=api . Caller type Caller interface { Call(ctx context.Context, args ethapi.TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *ethapi.StateOverride) (hexutil.Bytes, error) + CallWithState(ctx context.Context, args ethapi.TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, state *state.StateDB, overrides *ethapi.StateOverride) (hexutil.Bytes, error) } diff --git a/consensus/bor/api/caller_mock.go b/consensus/bor/api/caller_mock.go index 940c99d178..e734d6c899 100644 --- a/consensus/bor/api/caller_mock.go +++ b/consensus/bor/api/caller_mock.go @@ -9,6 +9,7 @@ import ( reflect "reflect" hexutil "github.com/ethereum/go-ethereum/common/hexutil" + state "github.com/ethereum/go-ethereum/core/state" ethapi "github.com/ethereum/go-ethereum/internal/ethapi" rpc "github.com/ethereum/go-ethereum/rpc" gomock "github.com/golang/mock/gomock" @@ -51,3 +52,18 @@ func (mr *MockCallerMockRecorder) Call(arg0, arg1, arg2, arg3 interface{}) *gomo mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Call", reflect.TypeOf((*MockCaller)(nil).Call), arg0, arg1, arg2, arg3) } + +// CallWithState mocks base method. +func (m *MockCaller) CallWithState(arg0 context.Context, arg1 ethapi.TransactionArgs, arg2 rpc.BlockNumberOrHash, arg3 *state.StateDB, arg4 *ethapi.StateOverride) (hexutil.Bytes, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CallWithState", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(hexutil.Bytes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CallWithState indicates an expected call of CallWithState. +func (mr *MockCallerMockRecorder) CallWithState(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallWithState", reflect.TypeOf((*MockCaller)(nil).CallWithState), arg0, arg1, arg2, arg3, arg4) +} diff --git a/consensus/bor/bor.go b/consensus/bor/bor.go index 24a894d611..3b1ad4dbf4 100644 --- a/consensus/bor/bor.go +++ b/consensus/bor/bor.go @@ -1184,30 +1184,42 @@ func (c *Bor) CommitStates( fetchStart := time.Now() number := header.Number.Uint64() - _lastStateID, err := c.GenesisContractsClient.LastStateId(number - 1) - if err != nil { - return nil, err - } - - var to time.Time + var ( + _lastStateID *big.Int + from uint64 + to time.Time + err error + ) if c.config.IsIndore(header.Number) { - stateSyncDelay := c.config.FetchStateSyncDelay(number) + // Fetch the LastStateId from contract via current state instance + _lastStateID, err = c.GenesisContractsClient.LastStateId(state, number-1, header.ParentHash) + if err != nil { + return nil, err + } + + stateSyncDelay := c.config.CalculateStateSyncDelay(number) to = time.Unix(int64(header.Time-stateSyncDelay), 0) } else { + _lastStateID, err = c.GenesisContractsClient.LastStateId(nil, number-1, header.ParentHash) + if err != nil { + return nil, err + } + to = time.Unix(int64(chain.Chain.GetHeaderByNumber(number-c.config.CalculateSprint(number)).Time), 0) } lastStateID := _lastStateID.Uint64() + from = lastStateID + 1 log.Info( "Fetching state updates from Heimdall", - "fromID", lastStateID+1, + "fromID", from, "to", to.Format(time.RFC3339)) - eventRecords, err := c.HeimdallClient.StateSyncEvents(ctx, lastStateID+1, to.Unix()) + eventRecords, err := c.HeimdallClient.StateSyncEvents(ctx, from, to.Unix()) if err != nil { - log.Error("Error occurred when fetching state sync events", "stateID", lastStateID+1, "error", err) + log.Error("Error occurred when fetching state sync events", "fromID", from, "to", to.Unix(), "err", err) } if c.config.OverrideStateSyncRecords != nil { diff --git a/consensus/bor/contract/client.go b/consensus/bor/contract/client.go index 9e9e1392dd..fa8ad215f2 100644 --- a/consensus/bor/contract/client.go +++ b/consensus/bor/contract/client.go @@ -100,8 +100,8 @@ func (gc *GenesisContractsClient) CommitState( return gasUsed, nil } -func (gc *GenesisContractsClient) LastStateId(snapshotNumber uint64) (*big.Int, error) { - blockNr := rpc.BlockNumber(snapshotNumber) +func (gc *GenesisContractsClient) LastStateId(state *state.StateDB, number uint64, hash common.Hash) (*big.Int, error) { + blockNr := rpc.BlockNumber(number) const method = "lastStateId" @@ -116,11 +116,13 @@ func (gc *GenesisContractsClient) LastStateId(snapshotNumber uint64) (*big.Int, toAddress := common.HexToAddress(gc.StateReceiverContract) gas := (hexutil.Uint64)(uint64(math.MaxUint64 / 2)) - result, err := gc.ethAPI.Call(context.Background(), ethapi.TransactionArgs{ + // Do a call with state so that we can fetch the last state ID from a given (incoming) + // state instead of local(canonical) chain. + result, err := gc.ethAPI.CallWithState(context.Background(), ethapi.TransactionArgs{ Gas: &gas, To: &toAddress, Data: &msgData, - }, rpc.BlockNumberOrHash{BlockNumber: &blockNr}, nil) + }, rpc.BlockNumberOrHash{BlockNumber: &blockNr, BlockHash: &hash}, state, nil) if err != nil { return nil, err } diff --git a/consensus/bor/genesis.go b/consensus/bor/genesis.go index 33de53f9ba..9519b18847 100644 --- a/consensus/bor/genesis.go +++ b/consensus/bor/genesis.go @@ -3,6 +3,7 @@ package bor import ( "math/big" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/consensus/bor/clerk" "github.com/ethereum/go-ethereum/consensus/bor/statefull" "github.com/ethereum/go-ethereum/core/state" @@ -12,5 +13,5 @@ import ( //go:generate mockgen -destination=./genesis_contract_mock.go -package=bor . GenesisContract type GenesisContract interface { CommitState(event *clerk.EventRecordWithTime, state *state.StateDB, header *types.Header, chCtx statefull.ChainContext) (uint64, error) - LastStateId(snapshotNumber uint64) (*big.Int, error) + LastStateId(state *state.StateDB, number uint64, hash common.Hash) (*big.Int, error) } diff --git a/consensus/bor/genesis_contract_mock.go b/consensus/bor/genesis_contract_mock.go index dfe9390509..0296cbe905 100644 --- a/consensus/bor/genesis_contract_mock.go +++ b/consensus/bor/genesis_contract_mock.go @@ -8,6 +8,7 @@ import ( big "math/big" reflect "reflect" + common "github.com/ethereum/go-ethereum/common" clerk "github.com/ethereum/go-ethereum/consensus/bor/clerk" statefull "github.com/ethereum/go-ethereum/consensus/bor/statefull" state "github.com/ethereum/go-ethereum/core/state" @@ -54,16 +55,16 @@ func (mr *MockGenesisContractMockRecorder) CommitState(arg0, arg1, arg2, arg3 in } // LastStateId mocks base method. -func (m *MockGenesisContract) LastStateId(arg0 uint64) (*big.Int, error) { +func (m *MockGenesisContract) LastStateId(arg0 *state.StateDB, arg1 uint64, arg2 common.Hash) (*big.Int, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LastStateId", arg0) + ret := m.ctrl.Call(m, "LastStateId", arg0, arg1, arg2) ret0, _ := ret[0].(*big.Int) ret1, _ := ret[1].(error) return ret0, ret1 } // LastStateId indicates an expected call of LastStateId. -func (mr *MockGenesisContractMockRecorder) LastStateId(arg0 interface{}) *gomock.Call { +func (mr *MockGenesisContractMockRecorder) LastStateId(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastStateId", reflect.TypeOf((*MockGenesisContract)(nil).LastStateId), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastStateId", reflect.TypeOf((*MockGenesisContract)(nil).LastStateId), arg0, arg1, arg2) } diff --git a/consensus/bor/span_mock.go b/consensus/bor/span_mock.go index 910e81716c..099807161c 100644 --- a/consensus/bor/span_mock.go +++ b/consensus/bor/span_mock.go @@ -1,5 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: consensus/bor/span.go +// Source: github.com/ethereum/go-ethereum/consensus/bor (interfaces: Spanner) // Package bor is a generated GoMock package. package bor @@ -42,60 +42,60 @@ func (m *MockSpanner) EXPECT() *MockSpannerMockRecorder { } // CommitSpan mocks base method. -func (m *MockSpanner) CommitSpan(ctx context.Context, heimdallSpan span.HeimdallSpan, state *state.StateDB, header *types.Header, chainContext core.ChainContext) error { +func (m *MockSpanner) CommitSpan(arg0 context.Context, arg1 span.HeimdallSpan, arg2 *state.StateDB, arg3 *types.Header, arg4 core.ChainContext) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CommitSpan", ctx, heimdallSpan, state, header, chainContext) + ret := m.ctrl.Call(m, "CommitSpan", arg0, arg1, arg2, arg3, arg4) ret0, _ := ret[0].(error) return ret0 } // CommitSpan indicates an expected call of CommitSpan. -func (mr *MockSpannerMockRecorder) CommitSpan(ctx, heimdallSpan, state, header, chainContext interface{}) *gomock.Call { +func (mr *MockSpannerMockRecorder) CommitSpan(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitSpan", reflect.TypeOf((*MockSpanner)(nil).CommitSpan), ctx, heimdallSpan, state, header, chainContext) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitSpan", reflect.TypeOf((*MockSpanner)(nil).CommitSpan), arg0, arg1, arg2, arg3, arg4) } // GetCurrentSpan mocks base method. -func (m *MockSpanner) GetCurrentSpan(ctx context.Context, headerHash common.Hash) (*span.Span, error) { +func (m *MockSpanner) GetCurrentSpan(arg0 context.Context, arg1 common.Hash) (*span.Span, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCurrentSpan", ctx, headerHash) + ret := m.ctrl.Call(m, "GetCurrentSpan", arg0, arg1) ret0, _ := ret[0].(*span.Span) ret1, _ := ret[1].(error) return ret0, ret1 } // GetCurrentSpan indicates an expected call of GetCurrentSpan. -func (mr *MockSpannerMockRecorder) GetCurrentSpan(ctx, headerHash interface{}) *gomock.Call { +func (mr *MockSpannerMockRecorder) GetCurrentSpan(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentSpan", reflect.TypeOf((*MockSpanner)(nil).GetCurrentSpan), ctx, headerHash) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentSpan", reflect.TypeOf((*MockSpanner)(nil).GetCurrentSpan), arg0, arg1) } // GetCurrentValidatorsByBlockNrOrHash mocks base method. -func (m *MockSpanner) GetCurrentValidatorsByBlockNrOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash, blockNumber uint64) ([]*valset.Validator, error) { +func (m *MockSpanner) GetCurrentValidatorsByBlockNrOrHash(arg0 context.Context, arg1 rpc.BlockNumberOrHash, arg2 uint64) ([]*valset.Validator, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCurrentValidatorsByBlockNrOrHash", ctx, blockNrOrHash, blockNumber) + ret := m.ctrl.Call(m, "GetCurrentValidatorsByBlockNrOrHash", arg0, arg1, arg2) ret0, _ := ret[0].([]*valset.Validator) ret1, _ := ret[1].(error) return ret0, ret1 } // GetCurrentValidatorsByBlockNrOrHash indicates an expected call of GetCurrentValidatorsByBlockNrOrHash. -func (mr *MockSpannerMockRecorder) GetCurrentValidatorsByBlockNrOrHash(ctx, blockNrOrHash, blockNumber interface{}) *gomock.Call { +func (mr *MockSpannerMockRecorder) GetCurrentValidatorsByBlockNrOrHash(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentValidatorsByBlockNrOrHash", reflect.TypeOf((*MockSpanner)(nil).GetCurrentValidatorsByBlockNrOrHash), ctx, blockNrOrHash, blockNumber) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentValidatorsByBlockNrOrHash", reflect.TypeOf((*MockSpanner)(nil).GetCurrentValidatorsByBlockNrOrHash), arg0, arg1, arg2) } // GetCurrentValidatorsByHash mocks base method. -func (m *MockSpanner) GetCurrentValidatorsByHash(ctx context.Context, headerHash common.Hash, blockNumber uint64) ([]*valset.Validator, error) { +func (m *MockSpanner) GetCurrentValidatorsByHash(arg0 context.Context, arg1 common.Hash, arg2 uint64) ([]*valset.Validator, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCurrentValidatorsByHash", ctx, headerHash, blockNumber) + ret := m.ctrl.Call(m, "GetCurrentValidatorsByHash", arg0, arg1, arg2) ret0, _ := ret[0].([]*valset.Validator) ret1, _ := ret[1].(error) return ret0, ret1 } // GetCurrentValidatorsByHash indicates an expected call of GetCurrentValidatorsByHash. -func (mr *MockSpannerMockRecorder) GetCurrentValidatorsByHash(ctx, headerHash, blockNumber interface{}) *gomock.Call { +func (mr *MockSpannerMockRecorder) GetCurrentValidatorsByHash(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentValidatorsByHash", reflect.TypeOf((*MockSpanner)(nil).GetCurrentValidatorsByHash), ctx, headerHash, blockNumber) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentValidatorsByHash", reflect.TypeOf((*MockSpanner)(nil).GetCurrentValidatorsByHash), arg0, arg1, arg2) } diff --git a/graphql/graphql.go b/graphql/graphql.go index cbd76465d6..e17ad65d6d 100644 --- a/graphql/graphql.go +++ b/graphql/graphql.go @@ -1006,7 +1006,8 @@ func (b *Block) Call(ctx context.Context, args struct { return nil, err } } - result, err := ethapi.DoCall(ctx, b.backend, args.Data, *b.numberOrHash, nil, b.backend.RPCEVMTimeout(), b.backend.RPCGasCap()) + + result, err := ethapi.DoCall(ctx, b.backend, args.Data, *b.numberOrHash, nil, nil, b.backend.RPCEVMTimeout(), b.backend.RPCGasCap()) if err != nil { return nil, err } @@ -1076,7 +1077,7 @@ func (p *Pending) Call(ctx context.Context, args struct { Data ethapi.TransactionArgs }) (*CallResult, error) { pendingBlockNr := rpc.BlockNumberOrHashWithNumber(rpc.PendingBlockNumber) - result, err := ethapi.DoCall(ctx, p.backend, args.Data, pendingBlockNr, nil, p.backend.RPCEVMTimeout(), p.backend.RPCGasCap()) + result, err := ethapi.DoCall(ctx, p.backend, args.Data, pendingBlockNr, nil, nil, p.backend.RPCEVMTimeout(), p.backend.RPCGasCap()) if err != nil { return nil, err } diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go index 885a5ebf2b..165b6ddc9b 100644 --- a/internal/ethapi/api.go +++ b/internal/ethapi/api.go @@ -987,16 +987,40 @@ func (diff *StateOverride) Apply(state *state.StateDB) error { return nil } -func DoCall(ctx context.Context, b Backend, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *StateOverride, timeout time.Duration, globalGasCap uint64) (*core.ExecutionResult, error) { +func DoCall(ctx context.Context, b Backend, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, state *state.StateDB, overrides *StateOverride, timeout time.Duration, globalGasCap uint64) (*core.ExecutionResult, error) { defer func(start time.Time) { log.Debug("Executing EVM call finished", "runtime", time.Since(start)) }(time.Now()) - state, header, err := b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash) - if state == nil || err != nil { - return nil, err + var ( + header *types.Header + err error + ) + + // Fetch the state and header from blockNumberOrHash if it's coming from normal eth_call path. + if state == nil { + state, header, err = b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash) + if state == nil || err != nil { + return nil, err + } + } else { + // Fetch the header from the given blockNumberOrHash. Note that this path is only taken + // when we're doing a call from bor consensus to fetch data from genesis contracts. It's + // necessary to fetch header using header hash as we might be experiencing a reorg and there + // can be multiple headers with same number. + header, err = b.HeaderByHash(ctx, *blockNrOrHash.BlockHash) + if header == nil || err != nil { + log.Warn("Error fetching header on CallWithState", "err", err) + return nil, err + } } + if err := overrides.Apply(state); err != nil { return nil, err } + + return doCallWithState(ctx, b, args, header, state, timeout, globalGasCap) +} + +func doCallWithState(ctx context.Context, b Backend, args TransactionArgs, header *types.Header, state *state.StateDB, timeout time.Duration, globalGasCap uint64) (*core.ExecutionResult, error) { // Setup context so it may be cancelled the call has completed // or, in case of unmetered gas, setup a context with a timeout. var cancel context.CancelFunc @@ -1080,7 +1104,32 @@ func (e *revertError) ErrorData() interface{} { // Note, this function doesn't make and changes in the state/blockchain and is // useful to execute and retrieve values. func (s *PublicBlockChainAPI) Call(ctx context.Context, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *StateOverride) (hexutil.Bytes, error) { - result, err := DoCall(ctx, s.b, args, blockNrOrHash, overrides, s.b.RPCEVMTimeout(), s.b.RPCGasCap()) + result, err := DoCall(ctx, s.b, args, blockNrOrHash, nil, overrides, s.b.RPCEVMTimeout(), s.b.RPCGasCap()) + if err != nil { + return nil, err + } + + if int(s.b.RPCRpcReturnDataLimit()) > 0 && len(result.ReturnData) > int(s.b.RPCRpcReturnDataLimit()) { + return nil, fmt.Errorf("call returned result of length %d exceeding limit %d", len(result.ReturnData), int(s.b.RPCRpcReturnDataLimit())) + } + + // If the result contains a revert reason, try to unpack and return it. + if len(result.Revert()) > 0 { + return nil, newRevertError(result) + } + + return result.Return(), result.Err +} + +// CallWithState executes the given transaction on the given state for +// the given block number. +// +// Additionally, the caller can specify a batch of contract for fields overriding. +// +// Note, this function doesn't make and changes in the state/blockchain and is +// useful to execute and retrieve values. +func (s *PublicBlockChainAPI) CallWithState(ctx context.Context, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, state *state.StateDB, overrides *StateOverride) (hexutil.Bytes, error) { + result, err := DoCall(ctx, s.b, args, blockNrOrHash, state, overrides, s.b.RPCEVMTimeout(), s.b.RPCGasCap()) if err != nil { return nil, err } @@ -1093,6 +1142,7 @@ func (s *PublicBlockChainAPI) Call(ctx context.Context, args TransactionArgs, bl if len(result.Revert()) > 0 { return nil, newRevertError(result) } + return result.Return(), result.Err } @@ -1170,7 +1220,7 @@ func DoEstimateGas(ctx context.Context, b Backend, args TransactionArgs, blockNr executable := func(gas uint64) (bool, *core.ExecutionResult, error) { args.Gas = (*hexutil.Uint64)(&gas) - result, err := DoCall(ctx, b, args, blockNrOrHash, nil, 0, gasCap) + result, err := DoCall(ctx, b, args, blockNrOrHash, nil, nil, 0, gasCap) if err != nil { if errors.Is(err, core.ErrIntrinsicGas) { return true, nil, nil // Special case, raise gas limit diff --git a/params/config.go b/params/config.go index 659b220de0..847d20e296 100644 --- a/params/config.go +++ b/params/config.go @@ -608,11 +608,11 @@ func (b *BorConfig) String() string { } func (c *BorConfig) CalculateProducerDelay(number uint64) uint64 { - return c.calculateSprintSizeHelper(c.ProducerDelay, number) + return borKeyValueConfigHelper(c.ProducerDelay, number) } func (c *BorConfig) CalculateSprint(number uint64) uint64 { - return c.calculateSprintSizeHelper(c.Sprint, number) + return borKeyValueConfigHelper(c.Sprint, number) } func (c *BorConfig) CalculateBackupMultiplier(number uint64) uint64 { @@ -635,8 +635,8 @@ func (c *BorConfig) IsIndore(number *big.Int) bool { return isForked(c.IndoreBlock, number) } -func (c *BorConfig) FetchStateSyncDelay(number uint64) uint64 { - return c.fetchStateSyncDelayHelper(c.StateSyncConfirmationDelay, number) +func (c *BorConfig) CalculateStateSyncDelay(number uint64) uint64 { + return borKeyValueConfigHelper(c.StateSyncConfirmationDelay, number) } // TODO: modify this function once the block number is finalized @@ -672,7 +672,7 @@ func (c *BorConfig) calculateBorConfigHelper(field map[string]uint64, number uin return field[keys[len(keys)-1]] } -func helperToRetriveKeyValue(field map[string]uint64, number uint64) uint64 { +func borKeyValueConfigHelper(field map[string]uint64, number uint64) uint64 { keys := make([]string, 0, len(field)) for k := range field { keys = append(keys, k) @@ -692,14 +692,6 @@ func helperToRetriveKeyValue(field map[string]uint64, number uint64) uint64 { return field[keys[len(keys)-1]] } -func (c *BorConfig) calculateSprintSizeHelper(field map[string]uint64, number uint64) uint64 { - return helperToRetriveKeyValue(field, number) -} - -func (c *BorConfig) fetchStateSyncDelayHelper(field map[string]uint64, number uint64) uint64 { - return helperToRetriveKeyValue(field, number) -} - func (c *BorConfig) CalculateBurntContract(number uint64) string { keys := make([]string, 0, len(c.BurntContract)) for k := range c.BurntContract { diff --git a/tests/bor/bor_test.go b/tests/bor/bor_test.go index 5469bbccd0..24c579caad 100644 --- a/tests/bor/bor_test.go +++ b/tests/bor/bor_test.go @@ -544,7 +544,7 @@ func TestFetchStateSyncEvents_2(t *testing.T) { insertNewBlock(t, chain, block) } - lastStateID, _ := _bor.GenesisContractsClient.LastStateId(sprintSize) + lastStateID, _ := _bor.GenesisContractsClient.LastStateId(nil, sprintSize, block.Hash()) // state 6 was not written require.Equal(t, uint64(4), lastStateID.Uint64()) @@ -573,7 +573,7 @@ func TestFetchStateSyncEvents_2(t *testing.T) { insertNewBlock(t, chain, block) } - lastStateID, _ = _bor.GenesisContractsClient.LastStateId(spanSize) + lastStateID, _ = _bor.GenesisContractsClient.LastStateId(nil, spanSize, block.Hash()) require.Equal(t, uint64(6), lastStateID.Uint64()) }