consensus/bor,eth/filters,miner,params,tests: fix mocks

Makefile

@@ -35,6 +35,7 @@ protoc:
 generate-mocks:
 	go generate mockgen -destination=./tests/bor/mocks/IHeimdallClient.go -package=mocks ./consensus/bor IHeimdallClient
 	go generate mockgen -destination=./eth/filters/IBackend.go -package=filters ./eth/filters Backend
+	go generate mockgen -destination=../eth/filters/IDatabase.go -package=filters . Database
 
 geth:
 	$(GORUN) build/ci.go install ./cmd/geth

consensus/bor/genesis_contract_mock.go

@@ -31,7 +31,6 @@ type MockGenesisContractMockRecorder struct {
 func NewMockGenesisContract(ctrl *gomock.Controller) *MockGenesisContract {
 	mock := &MockGenesisContract{ctrl: ctrl}
 	mock.recorder = &MockGenesisContractMockRecorder{mock}
-
 	return mock
 }
 
@@ -46,7 +45,6 @@ func (m *MockGenesisContract) CommitState(arg0 *clerk.EventRecordWithTime, arg1
 	ret := m.ctrl.Call(m, "CommitState", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].(uint64)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
@@ -62,7 +60,6 @@ func (m *MockGenesisContract) LastStateId(arg0 *state.StateDB, arg1 uint64, arg2
 	ret := m.ctrl.Call(m, "LastStateId", arg0, arg1, arg2)
 	ret0, _ := ret[0].(*big.Int)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 

consensus/bor/span_mock.go

@@ -33,7 +33,6 @@ type MockSpannerMockRecorder struct {
 func NewMockSpanner(ctrl *gomock.Controller) *MockSpanner {
 	mock := &MockSpanner{ctrl: ctrl}
 	mock.recorder = &MockSpannerMockRecorder{mock}
-
 	return mock
 }
 
@@ -47,7 +46,6 @@ func (m *MockSpanner) CommitSpan(arg0 context.Context, arg1 span.HeimdallSpan, a
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CommitSpan", arg0, arg1, arg2, arg3, arg4)
 	ret0, _ := ret[0].(error)
-
 	return ret0
 }
 
@@ -63,7 +61,6 @@ func (m *MockSpanner) GetCurrentSpan(arg0 context.Context, arg1 common.Hash) (*s
 	ret := m.ctrl.Call(m, "GetCurrentSpan", arg0, arg1)
 	ret0, _ := ret[0].(*span.Span)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
@@ -79,7 +76,6 @@ func (m *MockSpanner) GetCurrentValidatorsByBlockNrOrHash(arg0 context.Context,
 	ret := m.ctrl.Call(m, "GetCurrentValidatorsByBlockNrOrHash", arg0, arg1, arg2)
 	ret0, _ := ret[0].([]*valset.Validator)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
@@ -95,7 +91,6 @@ func (m *MockSpanner) GetCurrentValidatorsByHash(arg0 context.Context, arg1 comm
 	ret := m.ctrl.Call(m, "GetCurrentValidatorsByHash", arg0, arg1, arg2)
 	ret0, _ := ret[0].([]*valset.Validator)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 

eth/filters/IBackend.go

@@ -34,7 +34,6 @@ type MockBackendMockRecorder struct {
 func NewMockBackend(ctrl *gomock.Controller) *MockBackend {
 	mock := &MockBackend{ctrl: ctrl}
 	mock.recorder = &MockBackendMockRecorder{mock}
-
 	return mock
 }
 
@@ -49,7 +48,6 @@ func (m *MockBackend) BloomStatus() (uint64, uint64) {
 	ret := m.ctrl.Call(m, "BloomStatus")
 	ret0, _ := ret[0].(uint64)
 	ret1, _ := ret[1].(uint64)
-
 	return ret0, ret1
 }
 
@@ -64,7 +62,6 @@ func (m *MockBackend) ChainConfig() *params.ChainConfig {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ChainConfig")
 	ret0, _ := ret[0].(*params.ChainConfig)
-
 	return ret0
 }
 
@@ -79,7 +76,6 @@ func (m *MockBackend) ChainDb() ethdb.Database {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ChainDb")
 	ret0, _ := ret[0].(ethdb.Database)
-
 	return ret0
 }
 
@@ -94,7 +90,6 @@ func (m *MockBackend) CurrentHeader() *types.Header {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CurrentHeader")
 	ret0, _ := ret[0].(*types.Header)
-
 	return ret0
 }
 
@@ -105,115 +100,108 @@ func (mr *MockBackendMockRecorder) CurrentHeader() *gomock.Call {
 }
 
 // GetBody mocks base method.
-func (m *MockBackend) GetBody(ctx context.Context, hash common.Hash, number rpc.BlockNumber) (*types.Body, error) {
+func (m *MockBackend) GetBody(arg0 context.Context, arg1 common.Hash, arg2 rpc.BlockNumber) (*types.Body, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetBody", ctx, hash, number)
+	ret := m.ctrl.Call(m, "GetBody", arg0, arg1, arg2)
 	ret0, _ := ret[0].(*types.Body)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
 // GetBody indicates an expected call of GetBody.
-func (mr *MockBackendMockRecorder) GetBody(ctx, hash, number interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) GetBody(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBody", reflect.TypeOf((*MockBackend)(nil).GetBody), ctx, hash, number)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBody", reflect.TypeOf((*MockBackend)(nil).GetBody), arg0, arg1, arg2)
 }
 
 // GetBorBlockLogs mocks base method.
-func (m *MockBackend) GetBorBlockLogs(ctx context.Context, blockHash common.Hash) ([]*types.Log, error) {
+func (m *MockBackend) GetBorBlockLogs(arg0 context.Context, arg1 common.Hash) ([]*types.Log, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetBorBlockLogs", ctx, blockHash)
+	ret := m.ctrl.Call(m, "GetBorBlockLogs", arg0, arg1)
 	ret0, _ := ret[0].([]*types.Log)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
 // GetBorBlockLogs indicates an expected call of GetBorBlockLogs.
-func (mr *MockBackendMockRecorder) GetBorBlockLogs(ctx, blockHash interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) GetBorBlockLogs(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBorBlockLogs", reflect.TypeOf((*MockBackend)(nil).GetBorBlockLogs), ctx, blockHash)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBorBlockLogs", reflect.TypeOf((*MockBackend)(nil).GetBorBlockLogs), arg0, arg1)
 }
 
 // GetBorBlockReceipt mocks base method.
-func (m *MockBackend) GetBorBlockReceipt(ctx context.Context, blockHash common.Hash) (*types.Receipt, error) {
+func (m *MockBackend) GetBorBlockReceipt(arg0 context.Context, arg1 common.Hash) (*types.Receipt, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetBorBlockReceipt", ctx, blockHash)
+	ret := m.ctrl.Call(m, "GetBorBlockReceipt", arg0, arg1)
 	ret0, _ := ret[0].(*types.Receipt)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
 // GetBorBlockReceipt indicates an expected call of GetBorBlockReceipt.
-func (mr *MockBackendMockRecorder) GetBorBlockReceipt(ctx, blockHash interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) GetBorBlockReceipt(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBorBlockReceipt", reflect.TypeOf((*MockBackend)(nil).GetBorBlockReceipt), ctx, blockHash)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBorBlockReceipt", reflect.TypeOf((*MockBackend)(nil).GetBorBlockReceipt), arg0, arg1)
 }
 
 // GetLogs mocks base method.
-func (m *MockBackend) GetLogs(ctx context.Context, blockHash common.Hash, number uint64) ([][]*types.Log, error) {
+func (m *MockBackend) GetLogs(arg0 context.Context, arg1 common.Hash, arg2 uint64) ([][]*types.Log, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetLogs", ctx, blockHash, number)
+	ret := m.ctrl.Call(m, "GetLogs", arg0, arg1, arg2)
 	ret0, _ := ret[0].([][]*types.Log)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
 // GetLogs indicates an expected call of GetLogs.
-func (mr *MockBackendMockRecorder) GetLogs(ctx, blockHash, number interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) GetLogs(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogs", reflect.TypeOf((*MockBackend)(nil).GetLogs), ctx, blockHash, number)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogs", reflect.TypeOf((*MockBackend)(nil).GetLogs), arg0, arg1, arg2)
 }
 
 // GetReceipts mocks base method.
-func (m *MockBackend) GetReceipts(ctx context.Context, blockHash common.Hash) (types.Receipts, error) {
+func (m *MockBackend) GetReceipts(arg0 context.Context, arg1 common.Hash) (types.Receipts, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetReceipts", ctx, blockHash)
+	ret := m.ctrl.Call(m, "GetReceipts", arg0, arg1)
 	ret0, _ := ret[0].(types.Receipts)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
 // GetReceipts indicates an expected call of GetReceipts.
-func (mr *MockBackendMockRecorder) GetReceipts(ctx, blockHash interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) GetReceipts(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReceipts", reflect.TypeOf((*MockBackend)(nil).GetReceipts), ctx, blockHash)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReceipts", reflect.TypeOf((*MockBackend)(nil).GetReceipts), arg0, arg1)
 }
 
 // HeaderByHash mocks base method.
-func (m *MockBackend) HeaderByHash(ctx context.Context, blockHash common.Hash) (*types.Header, error) {
+func (m *MockBackend) HeaderByHash(arg0 context.Context, arg1 common.Hash) (*types.Header, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HeaderByHash", ctx, blockHash)
+	ret := m.ctrl.Call(m, "HeaderByHash", arg0, arg1)
 	ret0, _ := ret[0].(*types.Header)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
 // HeaderByHash indicates an expected call of HeaderByHash.
-func (mr *MockBackendMockRecorder) HeaderByHash(ctx, blockHash interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) HeaderByHash(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockBackend)(nil).HeaderByHash), ctx, blockHash)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockBackend)(nil).HeaderByHash), arg0, arg1)
 }
 
 // HeaderByNumber mocks base method.
-func (m *MockBackend) HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Header, error) {
+func (m *MockBackend) HeaderByNumber(arg0 context.Context, arg1 rpc.BlockNumber) (*types.Header, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HeaderByNumber", ctx, blockNr)
+	ret := m.ctrl.Call(m, "HeaderByNumber", arg0, arg1)
 	ret0, _ := ret[0].(*types.Header)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
 // HeaderByNumber indicates an expected call of HeaderByNumber.
-func (mr *MockBackendMockRecorder) HeaderByNumber(ctx, blockNr interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) HeaderByNumber(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockBackend)(nil).HeaderByNumber), ctx, blockNr)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockBackend)(nil).HeaderByNumber), arg0, arg1)
 }
 
 // PendingBlockAndReceipts mocks base method.
@@ -222,7 +210,6 @@ func (m *MockBackend) PendingBlockAndReceipts() (*types.Block, types.Receipts) {
 	ret := m.ctrl.Call(m, "PendingBlockAndReceipts")
 	ret0, _ := ret[0].(*types.Block)
 	ret1, _ := ret[1].(types.Receipts)
-
 	return ret0, ret1
 }
 
@@ -233,45 +220,43 @@ func (mr *MockBackendMockRecorder) PendingBlockAndReceipts() *gomock.Call {
 }
 
 // ServiceFilter mocks base method.
-func (m *MockBackend) ServiceFilter(ctx context.Context, session *bloombits.MatcherSession) {
+func (m *MockBackend) ServiceFilter(arg0 context.Context, arg1 *bloombits.MatcherSession) {
 	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "ServiceFilter", ctx, session)
+	m.ctrl.Call(m, "ServiceFilter", arg0, arg1)
 }
 
 // ServiceFilter indicates an expected call of ServiceFilter.
-func (mr *MockBackendMockRecorder) ServiceFilter(ctx, session interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) ServiceFilter(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceFilter", reflect.TypeOf((*MockBackend)(nil).ServiceFilter), ctx, session)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceFilter", reflect.TypeOf((*MockBackend)(nil).ServiceFilter), arg0, arg1)
 }
 
 // SubscribeChainEvent mocks base method.
-func (m *MockBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription {
+func (m *MockBackend) SubscribeChainEvent(arg0 chan<- core.ChainEvent) event.Subscription {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SubscribeChainEvent", ch)
+	ret := m.ctrl.Call(m, "SubscribeChainEvent", arg0)
 	ret0, _ := ret[0].(event.Subscription)
-
 	return ret0
 }
 
 // SubscribeChainEvent indicates an expected call of SubscribeChainEvent.
-func (mr *MockBackendMockRecorder) SubscribeChainEvent(ch interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) SubscribeChainEvent(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeChainEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeChainEvent), ch)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeChainEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeChainEvent), arg0)
 }
 
 // SubscribeLogsEvent mocks base method.
-func (m *MockBackend) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription {
+func (m *MockBackend) SubscribeLogsEvent(arg0 chan<- []*types.Log) event.Subscription {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SubscribeLogsEvent", ch)
+	ret := m.ctrl.Call(m, "SubscribeLogsEvent", arg0)
 	ret0, _ := ret[0].(event.Subscription)
-
 	return ret0
 }
 
 // SubscribeLogsEvent indicates an expected call of SubscribeLogsEvent.
-func (mr *MockBackendMockRecorder) SubscribeLogsEvent(ch interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) SubscribeLogsEvent(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeLogsEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeLogsEvent), ch)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeLogsEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeLogsEvent), arg0)
 }
 
 // SubscribeNewTxsEvent mocks base method.
@@ -279,7 +264,6 @@ func (m *MockBackend) SubscribeNewTxsEvent(arg0 chan<- core.NewTxsEvent) event.S
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SubscribeNewTxsEvent", arg0)
 	ret0, _ := ret[0].(event.Subscription)
-
 	return ret0
 }
 
@@ -290,46 +274,43 @@ func (mr *MockBackendMockRecorder) SubscribeNewTxsEvent(arg0 interface{}) *gomoc
 }
 
 // SubscribePendingLogsEvent mocks base method.
-func (m *MockBackend) SubscribePendingLogsEvent(ch chan<- []*types.Log) event.Subscription {
+func (m *MockBackend) SubscribePendingLogsEvent(arg0 chan<- []*types.Log) event.Subscription {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SubscribePendingLogsEvent", ch)
+	ret := m.ctrl.Call(m, "SubscribePendingLogsEvent", arg0)
 	ret0, _ := ret[0].(event.Subscription)
-
 	return ret0
 }
 
 // SubscribePendingLogsEvent indicates an expected call of SubscribePendingLogsEvent.
-func (mr *MockBackendMockRecorder) SubscribePendingLogsEvent(ch interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) SubscribePendingLogsEvent(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribePendingLogsEvent", reflect.TypeOf((*MockBackend)(nil).SubscribePendingLogsEvent), ch)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribePendingLogsEvent", reflect.TypeOf((*MockBackend)(nil).SubscribePendingLogsEvent), arg0)
 }
 
 // SubscribeRemovedLogsEvent mocks base method.
-func (m *MockBackend) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription {
+func (m *MockBackend) SubscribeRemovedLogsEvent(arg0 chan<- core.RemovedLogsEvent) event.Subscription {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SubscribeRemovedLogsEvent", ch)
+	ret := m.ctrl.Call(m, "SubscribeRemovedLogsEvent", arg0)
 	ret0, _ := ret[0].(event.Subscription)
-
 	return ret0
 }
 
 // SubscribeRemovedLogsEvent indicates an expected call of SubscribeRemovedLogsEvent.
-func (mr *MockBackendMockRecorder) SubscribeRemovedLogsEvent(ch interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) SubscribeRemovedLogsEvent(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeRemovedLogsEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeRemovedLogsEvent), ch)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeRemovedLogsEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeRemovedLogsEvent), arg0)
 }
 
 // SubscribeStateSyncEvent mocks base method.
-func (m *MockBackend) SubscribeStateSyncEvent(ch chan<- core.StateSyncEvent) event.Subscription {
+func (m *MockBackend) SubscribeStateSyncEvent(arg0 chan<- core.StateSyncEvent) event.Subscription {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SubscribeStateSyncEvent", ch)
+	ret := m.ctrl.Call(m, "SubscribeStateSyncEvent", arg0)
 	ret0, _ := ret[0].(event.Subscription)
-
 	return ret0
 }
 
 // SubscribeStateSyncEvent indicates an expected call of SubscribeStateSyncEvent.
-func (mr *MockBackendMockRecorder) SubscribeStateSyncEvent(ch interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) SubscribeStateSyncEvent(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeStateSyncEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeStateSyncEvent), ch)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeStateSyncEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeStateSyncEvent), arg0)
 }

eth/filters/IDatabase.go

@@ -26,7 +26,6 @@ type MockDatabaseMockRecorder struct {
 func NewMockDatabase(ctrl *gomock.Controller) *MockDatabase {
 	mock := &MockDatabase{ctrl: ctrl}
 	mock.recorder = &MockDatabaseMockRecorder{mock}
-
 	return mock
 }
 
@@ -41,7 +40,6 @@ func (m *MockDatabase) Ancient(arg0 string, arg1 uint64) ([]byte, error) {
 	ret := m.ctrl.Call(m, "Ancient", arg0, arg1)
 	ret0, _ := ret[0].([]byte)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
@@ -51,13 +49,27 @@ func (mr *MockDatabaseMockRecorder) Ancient(arg0, arg1 interface{}) *gomock.Call
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ancient", reflect.TypeOf((*MockDatabase)(nil).Ancient), arg0, arg1)
 }
 
+// AncientDatadir mocks base method.
+func (m *MockDatabase) AncientDatadir() (string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AncientDatadir")
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AncientDatadir indicates an expected call of AncientDatadir.
+func (mr *MockDatabaseMockRecorder) AncientDatadir() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AncientDatadir", reflect.TypeOf((*MockDatabase)(nil).AncientDatadir))
+}
+
 // AncientRange mocks base method.
 func (m *MockDatabase) AncientRange(arg0 string, arg1, arg2, arg3 uint64) ([][]byte, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AncientRange", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].([][]byte)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
@@ -73,7 +85,6 @@ func (m *MockDatabase) AncientSize(arg0 string) (uint64, error) {
 	ret := m.ctrl.Call(m, "AncientSize", arg0)
 	ret0, _ := ret[0].(uint64)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
@@ -89,7 +100,6 @@ func (m *MockDatabase) Ancients() (uint64, error) {
 	ret := m.ctrl.Call(m, "Ancients")
 	ret0, _ := ret[0].(uint64)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
@@ -104,7 +114,6 @@ func (m *MockDatabase) Close() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Close")
 	ret0, _ := ret[0].(error)
-
 	return ret0
 }
 
@@ -119,7 +128,6 @@ func (m *MockDatabase) Compact(arg0, arg1 []byte) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Compact", arg0, arg1)
 	ret0, _ := ret[0].(error)
-
 	return ret0
 }
 
@@ -134,7 +142,6 @@ func (m *MockDatabase) Delete(arg0 []byte) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Delete", arg0)
 	ret0, _ := ret[0].(error)
-
 	return ret0
 }
 
@@ -150,7 +157,6 @@ func (m *MockDatabase) Get(arg0 []byte) ([]byte, error) {
 	ret := m.ctrl.Call(m, "Get", arg0)
 	ret0, _ := ret[0].([]byte)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
@@ -166,7 +172,6 @@ func (m *MockDatabase) Has(arg0 []byte) (bool, error) {
 	ret := m.ctrl.Call(m, "Has", arg0)
 	ret0, _ := ret[0].(bool)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
@@ -182,7 +187,6 @@ func (m *MockDatabase) HasAncient(arg0 string, arg1 uint64) (bool, error) {
 	ret := m.ctrl.Call(m, "HasAncient", arg0, arg1)
 	ret0, _ := ret[0].(bool)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
@@ -197,7 +201,6 @@ func (m *MockDatabase) MigrateTable(arg0 string, arg1 func([]byte) ([]byte, erro
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "MigrateTable", arg0, arg1)
 	ret0, _ := ret[0].(error)
-
 	return ret0
 }
 
@@ -213,7 +216,6 @@ func (m *MockDatabase) ModifyAncients(arg0 func(ethdb.AncientWriteOp) error) (in
 	ret := m.ctrl.Call(m, "ModifyAncients", arg0)
 	ret0, _ := ret[0].(int64)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
@@ -228,7 +230,6 @@ func (m *MockDatabase) NewBatch() ethdb.Batch {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "NewBatch")
 	ret0, _ := ret[0].(ethdb.Batch)
-
 	return ret0
 }
 
@@ -243,7 +244,6 @@ func (m *MockDatabase) NewBatchWithSize(arg0 int) ethdb.Batch {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "NewBatchWithSize", arg0)
 	ret0, _ := ret[0].(ethdb.Batch)
-
 	return ret0
 }
 
@@ -258,7 +258,6 @@ func (m *MockDatabase) NewIterator(arg0, arg1 []byte) ethdb.Iterator {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "NewIterator", arg0, arg1)
 	ret0, _ := ret[0].(ethdb.Iterator)
-
 	return ret0
 }
 
@@ -274,7 +273,6 @@ func (m *MockDatabase) NewSnapshot() (ethdb.Snapshot, error) {
 	ret := m.ctrl.Call(m, "NewSnapshot")
 	ret0, _ := ret[0].(ethdb.Snapshot)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
@@ -289,7 +287,6 @@ func (m *MockDatabase) Put(arg0, arg1 []byte) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Put", arg0, arg1)
 	ret0, _ := ret[0].(error)
-
 	return ret0
 }
 
@@ -300,11 +297,10 @@ func (mr *MockDatabaseMockRecorder) Put(arg0, arg1 interface{}) *gomock.Call {
 }
 
 // ReadAncients mocks base method.
-func (m *MockDatabase) ReadAncients(arg0 func(ethdb.AncientReader) error) error {
+func (m *MockDatabase) ReadAncients(arg0 func(ethdb.AncientReaderOp) error) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ReadAncients", arg0)
 	ret0, _ := ret[0].(error)
-
 	return ret0
 }
 
@@ -320,7 +316,6 @@ func (m *MockDatabase) Stat(arg0 string) (string, error) {
 	ret := m.ctrl.Call(m, "Stat", arg0)
 	ret0, _ := ret[0].(string)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
@@ -335,7 +330,6 @@ func (m *MockDatabase) Sync() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Sync")
 	ret0, _ := ret[0].(error)
-
 	return ret0
 }
 
@@ -351,7 +345,6 @@ func (m *MockDatabase) Tail() (uint64, error) {
 	ret := m.ctrl.Call(m, "Tail")
 	ret0, _ := ret[0].(uint64)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
@@ -366,7 +359,6 @@ func (m *MockDatabase) TruncateHead(arg0 uint64) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "TruncateHead", arg0)
 	ret0, _ := ret[0].(error)
-
 	return ret0
 }
 
@@ -381,7 +373,6 @@ func (m *MockDatabase) TruncateTail(arg0 uint64) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "TruncateTail", arg0)
 	ret0, _ := ret[0].(error)
-
 	return ret0
 }
 

eth/filters/filter_system.go

@@ -57,6 +57,7 @@ func (cfg Config) withDefaults() Config {
 	return cfg
 }
 
+//go:generate mockgen -destination=../../eth/filters/IBackend.go -package=filters . Backend
 type Backend interface {
 	ChainDb() ethdb.Database
 	HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Header, error)

miner/fake_miner.go

@@ -79,19 +79,19 @@ func NewBorDefaultMiner(t *testing.T) *DefaultBorMiner {
 func createBorMiner(t *testing.T, ethAPIMock api.Caller, spanner bor.Spanner, heimdallClientMock bor.IHeimdallClient, contractMock bor.GenesisContract) (*Miner, *event.TypeMux, func(skipMiner bool)) {
 	t.Helper()
 
-	addr0 := common.Address{0x1}
+	// addr0 := common.Address{0x1}
 
-	genspec := &core.Genesis{
+	// genspec := &core.Genesis{
-		Alloc: map[common.Address]core.GenesisAccount{
+	// 	Alloc: map[common.Address]core.GenesisAccount{
-			addr0: {
+	// 		addr0: {
-				Balance: big.NewInt(0),
+	// 			Balance: big.NewInt(0),
-				Code:    []byte{0x1, 0x1},
+	// 			Code:    []byte{0x1, 0x1},
-			},
+	// 		},
-		},
+	// 	},
-	}
+	// }
 
 	// Create Ethash config
-	chainDB, _, chainConfig := NewDBForFakes(t)
+	chainDB, genspec, chainConfig := NewDBForFakes(t)
 
 	engine := NewFakeBor(t, chainDB, chainConfig, ethAPIMock, spanner, heimdallClientMock, contractMock)
 
@@ -200,6 +200,7 @@ type testBlockChain struct {
 func (bc *testBlockChain) CurrentBlock() *types.Header {
 	return &types.Header{
 		GasLimit: bc.gasLimit,
+		Number:   new(big.Int),
 	}
 }
 

params/config.go

@@ -507,7 +507,10 @@ var (
 		TerminalTotalDifficultyPassed: false,
 		Ethash:                        new(EthashConfig),
 		Clique:                        nil,
-		Bor:                           &BorConfig{BurntContract: map[string]string{"0": "0x000000000000000000000000000000000000dead"}},
+		Bor: &BorConfig{
+			Sprint: map[string]uint64{
+				"0": 4},
+			BurntContract: map[string]string{"0": "0x000000000000000000000000000000000000dead"}},
 	}
 
 	// NonActivatedConfig defines the chain configuration without activating

tests/bor/mocks/IHeimdallClient.go

@@ -29,7 +29,6 @@ type MockIHeimdallClientMockRecorder struct {
 func NewMockIHeimdallClient(ctrl *gomock.Controller) *MockIHeimdallClient {
 	mock := &MockIHeimdallClient{ctrl: ctrl}
 	mock.recorder = &MockIHeimdallClientMockRecorder{mock}
-
 	return mock
 }
 
@@ -56,7 +55,6 @@ func (m *MockIHeimdallClient) FetchCheckpoint(arg0 context.Context, arg1 int64)
 	ret := m.ctrl.Call(m, "FetchCheckpoint", arg0, arg1)
 	ret0, _ := ret[0].(*checkpoint.Checkpoint)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
@@ -72,7 +70,6 @@ func (m *MockIHeimdallClient) FetchCheckpointCount(arg0 context.Context) (int64,
 	ret := m.ctrl.Call(m, "FetchCheckpointCount", arg0)
 	ret0, _ := ret[0].(int64)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
@@ -88,7 +85,6 @@ func (m *MockIHeimdallClient) Span(arg0 context.Context, arg1 uint64) (*span.Hei
 	ret := m.ctrl.Call(m, "Span", arg0, arg1)
 	ret0, _ := ret[0].(*span.HeimdallSpan)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }
 
@@ -104,7 +100,6 @@ func (m *MockIHeimdallClient) StateSyncEvents(arg0 context.Context, arg1 uint64,
 	ret := m.ctrl.Call(m, "StateSyncEvents", arg0, arg1, arg2)
 	ret0, _ := ret[0].([]*clerk.EventRecordWithTime)
 	ret1, _ := ret[1].(error)
-
 	return ret0, ret1
 }