From 2c4f6f0b957b83ba35154e90f1b7efd44753bb9a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastian=20M=C3=BCller?= Date: Fri, 18 Oct 2024 12:43:15 -0700 Subject: [PATCH] update mocks --- emulator/mocks/emulator.go | 187 +++++++------ internal/mocks/access.go | 481 ++++++++++++++++---------------- internal/mocks/executiondata.go | 131 ++++----- storage/mocks/store.go | 97 +++---- 4 files changed, 450 insertions(+), 446 deletions(-) diff --git a/emulator/mocks/emulator.go b/emulator/mocks/emulator.go index aa54c2df..da986bf9 100644 --- a/emulator/mocks/emulator.go +++ b/emulator/mocks/emulator.go @@ -12,9 +12,9 @@ package mocks import ( reflect "reflect" - runtime "github.com/onflow/cadence/runtime" common "github.com/onflow/cadence/common" interpreter "github.com/onflow/cadence/interpreter" + runtime "github.com/onflow/cadence/runtime" emulator "github.com/onflow/flow-emulator/emulator" types "github.com/onflow/flow-emulator/types" access "github.com/onflow/flow-go/access" @@ -26,6 +26,7 @@ import ( type MockEmulator struct { ctrl *gomock.Controller recorder *MockEmulatorMockRecorder + isgomock struct{} } // MockEmulatorMockRecorder is the mock recorder for MockEmulator. @@ -46,17 +47,17 @@ func (m *MockEmulator) EXPECT() *MockEmulatorMockRecorder { } // AddTransaction mocks base method. -func (m *MockEmulator) AddTransaction(arg0 flow.TransactionBody) error { +func (m *MockEmulator) AddTransaction(tx flow.TransactionBody) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddTransaction", arg0) + ret := m.ctrl.Call(m, "AddTransaction", tx) ret0, _ := ret[0].(error) return ret0 } // AddTransaction indicates an expected call of AddTransaction. -func (mr *MockEmulatorMockRecorder) AddTransaction(arg0 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) AddTransaction(tx any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTransaction", reflect.TypeOf((*MockEmulator)(nil).AddTransaction), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTransaction", reflect.TypeOf((*MockEmulator)(nil).AddTransaction), tx) } // CommitBlock mocks base method. @@ -103,17 +104,17 @@ func (mr *MockEmulatorMockRecorder) CoverageReport() *gomock.Call { } // CreateSnapshot mocks base method. -func (m *MockEmulator) CreateSnapshot(arg0 string) error { +func (m *MockEmulator) CreateSnapshot(name string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSnapshot", arg0) + ret := m.ctrl.Call(m, "CreateSnapshot", name) ret0, _ := ret[0].(error) return ret0 } // CreateSnapshot indicates an expected call of CreateSnapshot. -func (mr *MockEmulatorMockRecorder) CreateSnapshot(arg0 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) CreateSnapshot(name any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockEmulator)(nil).CreateSnapshot), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockEmulator)(nil).CreateSnapshot), name) } // DisableAutoMine mocks base method. @@ -199,78 +200,78 @@ func (mr *MockEmulatorMockRecorder) ExecuteNextTransaction() *gomock.Call { } // ExecuteScript mocks base method. -func (m *MockEmulator) ExecuteScript(arg0 []byte, arg1 [][]byte) (*types.ScriptResult, error) { +func (m *MockEmulator) ExecuteScript(script []byte, arguments [][]byte) (*types.ScriptResult, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExecuteScript", arg0, arg1) + ret := m.ctrl.Call(m, "ExecuteScript", script, arguments) ret0, _ := ret[0].(*types.ScriptResult) ret1, _ := ret[1].(error) return ret0, ret1 } // ExecuteScript indicates an expected call of ExecuteScript. -func (mr *MockEmulatorMockRecorder) ExecuteScript(arg0, arg1 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) ExecuteScript(script, arguments any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteScript", reflect.TypeOf((*MockEmulator)(nil).ExecuteScript), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteScript", reflect.TypeOf((*MockEmulator)(nil).ExecuteScript), script, arguments) } // ExecuteScriptAtBlockHeight mocks base method. -func (m *MockEmulator) ExecuteScriptAtBlockHeight(arg0 []byte, arg1 [][]byte, arg2 uint64) (*types.ScriptResult, error) { +func (m *MockEmulator) ExecuteScriptAtBlockHeight(script []byte, arguments [][]byte, blockHeight uint64) (*types.ScriptResult, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExecuteScriptAtBlockHeight", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "ExecuteScriptAtBlockHeight", script, arguments, blockHeight) ret0, _ := ret[0].(*types.ScriptResult) ret1, _ := ret[1].(error) return ret0, ret1 } // ExecuteScriptAtBlockHeight indicates an expected call of ExecuteScriptAtBlockHeight. -func (mr *MockEmulatorMockRecorder) ExecuteScriptAtBlockHeight(arg0, arg1, arg2 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) ExecuteScriptAtBlockHeight(script, arguments, blockHeight any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteScriptAtBlockHeight", reflect.TypeOf((*MockEmulator)(nil).ExecuteScriptAtBlockHeight), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteScriptAtBlockHeight", reflect.TypeOf((*MockEmulator)(nil).ExecuteScriptAtBlockHeight), script, arguments, blockHeight) } // ExecuteScriptAtBlockID mocks base method. -func (m *MockEmulator) ExecuteScriptAtBlockID(arg0 []byte, arg1 [][]byte, arg2 flow.Identifier) (*types.ScriptResult, error) { +func (m *MockEmulator) ExecuteScriptAtBlockID(script []byte, arguments [][]byte, id flow.Identifier) (*types.ScriptResult, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExecuteScriptAtBlockID", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "ExecuteScriptAtBlockID", script, arguments, id) ret0, _ := ret[0].(*types.ScriptResult) ret1, _ := ret[1].(error) return ret0, ret1 } // ExecuteScriptAtBlockID indicates an expected call of ExecuteScriptAtBlockID. -func (mr *MockEmulatorMockRecorder) ExecuteScriptAtBlockID(arg0, arg1, arg2 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) ExecuteScriptAtBlockID(script, arguments, id any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteScriptAtBlockID", reflect.TypeOf((*MockEmulator)(nil).ExecuteScriptAtBlockID), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteScriptAtBlockID", reflect.TypeOf((*MockEmulator)(nil).ExecuteScriptAtBlockID), script, arguments, id) } // GetAccount mocks base method. -func (m *MockEmulator) GetAccount(arg0 flow.Address) (*flow.Account, error) { +func (m *MockEmulator) GetAccount(address flow.Address) (*flow.Account, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAccount", arg0) + ret := m.ctrl.Call(m, "GetAccount", address) ret0, _ := ret[0].(*flow.Account) ret1, _ := ret[1].(error) return ret0, ret1 } // GetAccount indicates an expected call of GetAccount. -func (mr *MockEmulatorMockRecorder) GetAccount(arg0 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) GetAccount(address any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccount", reflect.TypeOf((*MockEmulator)(nil).GetAccount), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccount", reflect.TypeOf((*MockEmulator)(nil).GetAccount), address) } // GetAccountAtBlockHeight mocks base method. -func (m *MockEmulator) GetAccountAtBlockHeight(arg0 flow.Address, arg1 uint64) (*flow.Account, error) { +func (m *MockEmulator) GetAccountAtBlockHeight(address flow.Address, blockHeight uint64) (*flow.Account, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAccountAtBlockHeight", arg0, arg1) + ret := m.ctrl.Call(m, "GetAccountAtBlockHeight", address, blockHeight) ret0, _ := ret[0].(*flow.Account) ret1, _ := ret[1].(error) return ret0, ret1 } // GetAccountAtBlockHeight indicates an expected call of GetAccountAtBlockHeight. -func (mr *MockEmulatorMockRecorder) GetAccountAtBlockHeight(arg0, arg1 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) GetAccountAtBlockHeight(address, blockHeight any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountAtBlockHeight", reflect.TypeOf((*MockEmulator)(nil).GetAccountAtBlockHeight), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountAtBlockHeight", reflect.TypeOf((*MockEmulator)(nil).GetAccountAtBlockHeight), address, blockHeight) } // GetAccountByIndex mocks base method. @@ -289,123 +290,123 @@ func (mr *MockEmulatorMockRecorder) GetAccountByIndex(arg0 any) *gomock.Call { } // GetAccountUnsafe mocks base method. -func (m *MockEmulator) GetAccountUnsafe(arg0 flow.Address) (*flow.Account, error) { +func (m *MockEmulator) GetAccountUnsafe(address flow.Address) (*flow.Account, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAccountUnsafe", arg0) + ret := m.ctrl.Call(m, "GetAccountUnsafe", address) ret0, _ := ret[0].(*flow.Account) ret1, _ := ret[1].(error) return ret0, ret1 } // GetAccountUnsafe indicates an expected call of GetAccountUnsafe. -func (mr *MockEmulatorMockRecorder) GetAccountUnsafe(arg0 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) GetAccountUnsafe(address any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountUnsafe", reflect.TypeOf((*MockEmulator)(nil).GetAccountUnsafe), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountUnsafe", reflect.TypeOf((*MockEmulator)(nil).GetAccountUnsafe), address) } // GetBlockByHeight mocks base method. -func (m *MockEmulator) GetBlockByHeight(arg0 uint64) (*flow.Block, error) { +func (m *MockEmulator) GetBlockByHeight(height uint64) (*flow.Block, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetBlockByHeight", arg0) + ret := m.ctrl.Call(m, "GetBlockByHeight", height) ret0, _ := ret[0].(*flow.Block) ret1, _ := ret[1].(error) return ret0, ret1 } // GetBlockByHeight indicates an expected call of GetBlockByHeight. -func (mr *MockEmulatorMockRecorder) GetBlockByHeight(arg0 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) GetBlockByHeight(height any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockByHeight", reflect.TypeOf((*MockEmulator)(nil).GetBlockByHeight), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockByHeight", reflect.TypeOf((*MockEmulator)(nil).GetBlockByHeight), height) } // GetBlockByID mocks base method. -func (m *MockEmulator) GetBlockByID(arg0 flow.Identifier) (*flow.Block, error) { +func (m *MockEmulator) GetBlockByID(id flow.Identifier) (*flow.Block, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetBlockByID", arg0) + ret := m.ctrl.Call(m, "GetBlockByID", id) ret0, _ := ret[0].(*flow.Block) ret1, _ := ret[1].(error) return ret0, ret1 } // GetBlockByID indicates an expected call of GetBlockByID. -func (mr *MockEmulatorMockRecorder) GetBlockByID(arg0 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) GetBlockByID(id any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockByID", reflect.TypeOf((*MockEmulator)(nil).GetBlockByID), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockByID", reflect.TypeOf((*MockEmulator)(nil).GetBlockByID), id) } // GetCollectionByID mocks base method. -func (m *MockEmulator) GetCollectionByID(arg0 flow.Identifier) (*flow.LightCollection, error) { +func (m *MockEmulator) GetCollectionByID(colID flow.Identifier) (*flow.LightCollection, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCollectionByID", arg0) + ret := m.ctrl.Call(m, "GetCollectionByID", colID) ret0, _ := ret[0].(*flow.LightCollection) ret1, _ := ret[1].(error) return ret0, ret1 } // GetCollectionByID indicates an expected call of GetCollectionByID. -func (mr *MockEmulatorMockRecorder) GetCollectionByID(arg0 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) GetCollectionByID(colID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCollectionByID", reflect.TypeOf((*MockEmulator)(nil).GetCollectionByID), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCollectionByID", reflect.TypeOf((*MockEmulator)(nil).GetCollectionByID), colID) } // GetEventsByHeight mocks base method. -func (m *MockEmulator) GetEventsByHeight(arg0 uint64, arg1 string) ([]flow.Event, error) { +func (m *MockEmulator) GetEventsByHeight(blockHeight uint64, eventType string) ([]flow.Event, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetEventsByHeight", arg0, arg1) + ret := m.ctrl.Call(m, "GetEventsByHeight", blockHeight, eventType) ret0, _ := ret[0].([]flow.Event) ret1, _ := ret[1].(error) return ret0, ret1 } // GetEventsByHeight indicates an expected call of GetEventsByHeight. -func (mr *MockEmulatorMockRecorder) GetEventsByHeight(arg0, arg1 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) GetEventsByHeight(blockHeight, eventType any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEventsByHeight", reflect.TypeOf((*MockEmulator)(nil).GetEventsByHeight), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEventsByHeight", reflect.TypeOf((*MockEmulator)(nil).GetEventsByHeight), blockHeight, eventType) } // GetEventsForBlockIDs mocks base method. -func (m *MockEmulator) GetEventsForBlockIDs(arg0 string, arg1 []flow.Identifier) ([]flow.BlockEvents, error) { +func (m *MockEmulator) GetEventsForBlockIDs(eventType string, blockIDs []flow.Identifier) ([]flow.BlockEvents, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetEventsForBlockIDs", arg0, arg1) + ret := m.ctrl.Call(m, "GetEventsForBlockIDs", eventType, blockIDs) ret0, _ := ret[0].([]flow.BlockEvents) ret1, _ := ret[1].(error) return ret0, ret1 } // GetEventsForBlockIDs indicates an expected call of GetEventsForBlockIDs. -func (mr *MockEmulatorMockRecorder) GetEventsForBlockIDs(arg0, arg1 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) GetEventsForBlockIDs(eventType, blockIDs any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEventsForBlockIDs", reflect.TypeOf((*MockEmulator)(nil).GetEventsForBlockIDs), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEventsForBlockIDs", reflect.TypeOf((*MockEmulator)(nil).GetEventsForBlockIDs), eventType, blockIDs) } // GetEventsForHeightRange mocks base method. -func (m *MockEmulator) GetEventsForHeightRange(arg0 string, arg1, arg2 uint64) ([]flow.BlockEvents, error) { +func (m *MockEmulator) GetEventsForHeightRange(eventType string, startHeight, endHeight uint64) ([]flow.BlockEvents, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetEventsForHeightRange", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "GetEventsForHeightRange", eventType, startHeight, endHeight) ret0, _ := ret[0].([]flow.BlockEvents) ret1, _ := ret[1].(error) return ret0, ret1 } // GetEventsForHeightRange indicates an expected call of GetEventsForHeightRange. -func (mr *MockEmulatorMockRecorder) GetEventsForHeightRange(arg0, arg1, arg2 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) GetEventsForHeightRange(eventType, startHeight, endHeight any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEventsForHeightRange", reflect.TypeOf((*MockEmulator)(nil).GetEventsForHeightRange), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEventsForHeightRange", reflect.TypeOf((*MockEmulator)(nil).GetEventsForHeightRange), eventType, startHeight, endHeight) } // GetFullCollectionByID mocks base method. -func (m *MockEmulator) GetFullCollectionByID(arg0 flow.Identifier) (*flow.Collection, error) { +func (m *MockEmulator) GetFullCollectionByID(colID flow.Identifier) (*flow.Collection, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetFullCollectionByID", arg0) + ret := m.ctrl.Call(m, "GetFullCollectionByID", colID) ret0, _ := ret[0].(*flow.Collection) ret1, _ := ret[1].(error) return ret0, ret1 } // GetFullCollectionByID indicates an expected call of GetFullCollectionByID. -func (mr *MockEmulatorMockRecorder) GetFullCollectionByID(arg0 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) GetFullCollectionByID(colID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFullCollectionByID", reflect.TypeOf((*MockEmulator)(nil).GetFullCollectionByID), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFullCollectionByID", reflect.TypeOf((*MockEmulator)(nil).GetFullCollectionByID), colID) } // GetLatestBlock mocks base method. @@ -453,91 +454,91 @@ func (mr *MockEmulatorMockRecorder) GetNetworkParameters() *gomock.Call { } // GetSourceFile mocks base method. -func (m *MockEmulator) GetSourceFile(arg0 common.Location) string { +func (m *MockEmulator) GetSourceFile(location common.Location) string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSourceFile", arg0) + ret := m.ctrl.Call(m, "GetSourceFile", location) ret0, _ := ret[0].(string) return ret0 } // GetSourceFile indicates an expected call of GetSourceFile. -func (mr *MockEmulatorMockRecorder) GetSourceFile(arg0 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) GetSourceFile(location any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSourceFile", reflect.TypeOf((*MockEmulator)(nil).GetSourceFile), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSourceFile", reflect.TypeOf((*MockEmulator)(nil).GetSourceFile), location) } // GetTransaction mocks base method. -func (m *MockEmulator) GetTransaction(arg0 flow.Identifier) (*flow.TransactionBody, error) { +func (m *MockEmulator) GetTransaction(txID flow.Identifier) (*flow.TransactionBody, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransaction", arg0) + ret := m.ctrl.Call(m, "GetTransaction", txID) ret0, _ := ret[0].(*flow.TransactionBody) ret1, _ := ret[1].(error) return ret0, ret1 } // GetTransaction indicates an expected call of GetTransaction. -func (mr *MockEmulatorMockRecorder) GetTransaction(arg0 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) GetTransaction(txID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransaction", reflect.TypeOf((*MockEmulator)(nil).GetTransaction), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransaction", reflect.TypeOf((*MockEmulator)(nil).GetTransaction), txID) } // GetTransactionResult mocks base method. -func (m *MockEmulator) GetTransactionResult(arg0 flow.Identifier) (*access.TransactionResult, error) { +func (m *MockEmulator) GetTransactionResult(txID flow.Identifier) (*access.TransactionResult, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransactionResult", arg0) + ret := m.ctrl.Call(m, "GetTransactionResult", txID) ret0, _ := ret[0].(*access.TransactionResult) ret1, _ := ret[1].(error) return ret0, ret1 } // GetTransactionResult indicates an expected call of GetTransactionResult. -func (mr *MockEmulatorMockRecorder) GetTransactionResult(arg0 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) GetTransactionResult(txID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransactionResult", reflect.TypeOf((*MockEmulator)(nil).GetTransactionResult), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransactionResult", reflect.TypeOf((*MockEmulator)(nil).GetTransactionResult), txID) } // GetTransactionResultsByBlockID mocks base method. -func (m *MockEmulator) GetTransactionResultsByBlockID(arg0 flow.Identifier) ([]*access.TransactionResult, error) { +func (m *MockEmulator) GetTransactionResultsByBlockID(blockID flow.Identifier) ([]*access.TransactionResult, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransactionResultsByBlockID", arg0) + ret := m.ctrl.Call(m, "GetTransactionResultsByBlockID", blockID) ret0, _ := ret[0].([]*access.TransactionResult) ret1, _ := ret[1].(error) return ret0, ret1 } // GetTransactionResultsByBlockID indicates an expected call of GetTransactionResultsByBlockID. -func (mr *MockEmulatorMockRecorder) GetTransactionResultsByBlockID(arg0 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) GetTransactionResultsByBlockID(blockID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransactionResultsByBlockID", reflect.TypeOf((*MockEmulator)(nil).GetTransactionResultsByBlockID), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransactionResultsByBlockID", reflect.TypeOf((*MockEmulator)(nil).GetTransactionResultsByBlockID), blockID) } // GetTransactionsByBlockID mocks base method. -func (m *MockEmulator) GetTransactionsByBlockID(arg0 flow.Identifier) ([]*flow.TransactionBody, error) { +func (m *MockEmulator) GetTransactionsByBlockID(blockID flow.Identifier) ([]*flow.TransactionBody, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransactionsByBlockID", arg0) + ret := m.ctrl.Call(m, "GetTransactionsByBlockID", blockID) ret0, _ := ret[0].([]*flow.TransactionBody) ret1, _ := ret[1].(error) return ret0, ret1 } // GetTransactionsByBlockID indicates an expected call of GetTransactionsByBlockID. -func (mr *MockEmulatorMockRecorder) GetTransactionsByBlockID(arg0 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) GetTransactionsByBlockID(blockID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransactionsByBlockID", reflect.TypeOf((*MockEmulator)(nil).GetTransactionsByBlockID), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransactionsByBlockID", reflect.TypeOf((*MockEmulator)(nil).GetTransactionsByBlockID), blockID) } // LoadSnapshot mocks base method. -func (m *MockEmulator) LoadSnapshot(arg0 string) error { +func (m *MockEmulator) LoadSnapshot(name string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LoadSnapshot", arg0) + ret := m.ctrl.Call(m, "LoadSnapshot", name) ret0, _ := ret[0].(error) return ret0 } // LoadSnapshot indicates an expected call of LoadSnapshot. -func (mr *MockEmulatorMockRecorder) LoadSnapshot(arg0 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) LoadSnapshot(name any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadSnapshot", reflect.TypeOf((*MockEmulator)(nil).LoadSnapshot), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadSnapshot", reflect.TypeOf((*MockEmulator)(nil).LoadSnapshot), name) } // Ping mocks base method. @@ -567,31 +568,31 @@ func (mr *MockEmulatorMockRecorder) ResetCoverageReport() *gomock.Call { } // RollbackToBlockHeight mocks base method. -func (m *MockEmulator) RollbackToBlockHeight(arg0 uint64) error { +func (m *MockEmulator) RollbackToBlockHeight(height uint64) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RollbackToBlockHeight", arg0) + ret := m.ctrl.Call(m, "RollbackToBlockHeight", height) ret0, _ := ret[0].(error) return ret0 } // RollbackToBlockHeight indicates an expected call of RollbackToBlockHeight. -func (mr *MockEmulatorMockRecorder) RollbackToBlockHeight(arg0 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) RollbackToBlockHeight(height any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackToBlockHeight", reflect.TypeOf((*MockEmulator)(nil).RollbackToBlockHeight), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackToBlockHeight", reflect.TypeOf((*MockEmulator)(nil).RollbackToBlockHeight), height) } // SendTransaction mocks base method. -func (m *MockEmulator) SendTransaction(arg0 *flow.TransactionBody) error { +func (m *MockEmulator) SendTransaction(tx *flow.TransactionBody) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SendTransaction", arg0) + ret := m.ctrl.Call(m, "SendTransaction", tx) ret0, _ := ret[0].(error) return ret0 } // SendTransaction indicates an expected call of SendTransaction. -func (mr *MockEmulatorMockRecorder) SendTransaction(arg0 any) *gomock.Call { +func (mr *MockEmulatorMockRecorder) SendTransaction(tx any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTransaction", reflect.TypeOf((*MockEmulator)(nil).SendTransaction), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTransaction", reflect.TypeOf((*MockEmulator)(nil).SendTransaction), tx) } // ServiceKey mocks base method. diff --git a/internal/mocks/access.go b/internal/mocks/access.go index d569f0cf..9ef655e8 100644 --- a/internal/mocks/access.go +++ b/internal/mocks/access.go @@ -22,6 +22,7 @@ import ( type MockAccessAPIClient struct { ctrl *gomock.Controller recorder *MockAccessAPIClientMockRecorder + isgomock struct{} } // MockAccessAPIClientMockRecorder is the mock recorder for MockAccessAPIClient. @@ -42,10 +43,10 @@ func (m *MockAccessAPIClient) EXPECT() *MockAccessAPIClientMockRecorder { } // ExecuteScriptAtBlockHeight mocks base method. -func (m *MockAccessAPIClient) ExecuteScriptAtBlockHeight(arg0 context.Context, arg1 *access.ExecuteScriptAtBlockHeightRequest, arg2 ...grpc.CallOption) (*access.ExecuteScriptResponse, error) { +func (m *MockAccessAPIClient) ExecuteScriptAtBlockHeight(ctx context.Context, in *access.ExecuteScriptAtBlockHeightRequest, opts ...grpc.CallOption) (*access.ExecuteScriptResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ExecuteScriptAtBlockHeight", varargs...) @@ -55,17 +56,17 @@ func (m *MockAccessAPIClient) ExecuteScriptAtBlockHeight(arg0 context.Context, a } // ExecuteScriptAtBlockHeight indicates an expected call of ExecuteScriptAtBlockHeight. -func (mr *MockAccessAPIClientMockRecorder) ExecuteScriptAtBlockHeight(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) ExecuteScriptAtBlockHeight(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteScriptAtBlockHeight", reflect.TypeOf((*MockAccessAPIClient)(nil).ExecuteScriptAtBlockHeight), varargs...) } // ExecuteScriptAtBlockID mocks base method. -func (m *MockAccessAPIClient) ExecuteScriptAtBlockID(arg0 context.Context, arg1 *access.ExecuteScriptAtBlockIDRequest, arg2 ...grpc.CallOption) (*access.ExecuteScriptResponse, error) { +func (m *MockAccessAPIClient) ExecuteScriptAtBlockID(ctx context.Context, in *access.ExecuteScriptAtBlockIDRequest, opts ...grpc.CallOption) (*access.ExecuteScriptResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ExecuteScriptAtBlockID", varargs...) @@ -75,17 +76,17 @@ func (m *MockAccessAPIClient) ExecuteScriptAtBlockID(arg0 context.Context, arg1 } // ExecuteScriptAtBlockID indicates an expected call of ExecuteScriptAtBlockID. -func (mr *MockAccessAPIClientMockRecorder) ExecuteScriptAtBlockID(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) ExecuteScriptAtBlockID(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteScriptAtBlockID", reflect.TypeOf((*MockAccessAPIClient)(nil).ExecuteScriptAtBlockID), varargs...) } // ExecuteScriptAtLatestBlock mocks base method. -func (m *MockAccessAPIClient) ExecuteScriptAtLatestBlock(arg0 context.Context, arg1 *access.ExecuteScriptAtLatestBlockRequest, arg2 ...grpc.CallOption) (*access.ExecuteScriptResponse, error) { +func (m *MockAccessAPIClient) ExecuteScriptAtLatestBlock(ctx context.Context, in *access.ExecuteScriptAtLatestBlockRequest, opts ...grpc.CallOption) (*access.ExecuteScriptResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ExecuteScriptAtLatestBlock", varargs...) @@ -95,17 +96,17 @@ func (m *MockAccessAPIClient) ExecuteScriptAtLatestBlock(arg0 context.Context, a } // ExecuteScriptAtLatestBlock indicates an expected call of ExecuteScriptAtLatestBlock. -func (mr *MockAccessAPIClientMockRecorder) ExecuteScriptAtLatestBlock(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) ExecuteScriptAtLatestBlock(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteScriptAtLatestBlock", reflect.TypeOf((*MockAccessAPIClient)(nil).ExecuteScriptAtLatestBlock), varargs...) } // GetAccount mocks base method. -func (m *MockAccessAPIClient) GetAccount(arg0 context.Context, arg1 *access.GetAccountRequest, arg2 ...grpc.CallOption) (*access.GetAccountResponse, error) { +func (m *MockAccessAPIClient) GetAccount(ctx context.Context, in *access.GetAccountRequest, opts ...grpc.CallOption) (*access.GetAccountResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetAccount", varargs...) @@ -115,17 +116,17 @@ func (m *MockAccessAPIClient) GetAccount(arg0 context.Context, arg1 *access.GetA } // GetAccount indicates an expected call of GetAccount. -func (mr *MockAccessAPIClientMockRecorder) GetAccount(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetAccount(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccount", reflect.TypeOf((*MockAccessAPIClient)(nil).GetAccount), varargs...) } // GetAccountAtBlockHeight mocks base method. -func (m *MockAccessAPIClient) GetAccountAtBlockHeight(arg0 context.Context, arg1 *access.GetAccountAtBlockHeightRequest, arg2 ...grpc.CallOption) (*access.AccountResponse, error) { +func (m *MockAccessAPIClient) GetAccountAtBlockHeight(ctx context.Context, in *access.GetAccountAtBlockHeightRequest, opts ...grpc.CallOption) (*access.AccountResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetAccountAtBlockHeight", varargs...) @@ -135,17 +136,17 @@ func (m *MockAccessAPIClient) GetAccountAtBlockHeight(arg0 context.Context, arg1 } // GetAccountAtBlockHeight indicates an expected call of GetAccountAtBlockHeight. -func (mr *MockAccessAPIClientMockRecorder) GetAccountAtBlockHeight(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetAccountAtBlockHeight(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountAtBlockHeight", reflect.TypeOf((*MockAccessAPIClient)(nil).GetAccountAtBlockHeight), varargs...) } // GetAccountAtLatestBlock mocks base method. -func (m *MockAccessAPIClient) GetAccountAtLatestBlock(arg0 context.Context, arg1 *access.GetAccountAtLatestBlockRequest, arg2 ...grpc.CallOption) (*access.AccountResponse, error) { +func (m *MockAccessAPIClient) GetAccountAtLatestBlock(ctx context.Context, in *access.GetAccountAtLatestBlockRequest, opts ...grpc.CallOption) (*access.AccountResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetAccountAtLatestBlock", varargs...) @@ -155,17 +156,17 @@ func (m *MockAccessAPIClient) GetAccountAtLatestBlock(arg0 context.Context, arg1 } // GetAccountAtLatestBlock indicates an expected call of GetAccountAtLatestBlock. -func (mr *MockAccessAPIClientMockRecorder) GetAccountAtLatestBlock(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetAccountAtLatestBlock(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountAtLatestBlock", reflect.TypeOf((*MockAccessAPIClient)(nil).GetAccountAtLatestBlock), varargs...) } // GetAccountBalanceAtBlockHeight mocks base method. -func (m *MockAccessAPIClient) GetAccountBalanceAtBlockHeight(arg0 context.Context, arg1 *access.GetAccountBalanceAtBlockHeightRequest, arg2 ...grpc.CallOption) (*access.AccountBalanceResponse, error) { +func (m *MockAccessAPIClient) GetAccountBalanceAtBlockHeight(ctx context.Context, in *access.GetAccountBalanceAtBlockHeightRequest, opts ...grpc.CallOption) (*access.AccountBalanceResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetAccountBalanceAtBlockHeight", varargs...) @@ -175,17 +176,17 @@ func (m *MockAccessAPIClient) GetAccountBalanceAtBlockHeight(arg0 context.Contex } // GetAccountBalanceAtBlockHeight indicates an expected call of GetAccountBalanceAtBlockHeight. -func (mr *MockAccessAPIClientMockRecorder) GetAccountBalanceAtBlockHeight(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetAccountBalanceAtBlockHeight(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountBalanceAtBlockHeight", reflect.TypeOf((*MockAccessAPIClient)(nil).GetAccountBalanceAtBlockHeight), varargs...) } // GetAccountBalanceAtLatestBlock mocks base method. -func (m *MockAccessAPIClient) GetAccountBalanceAtLatestBlock(arg0 context.Context, arg1 *access.GetAccountBalanceAtLatestBlockRequest, arg2 ...grpc.CallOption) (*access.AccountBalanceResponse, error) { +func (m *MockAccessAPIClient) GetAccountBalanceAtLatestBlock(ctx context.Context, in *access.GetAccountBalanceAtLatestBlockRequest, opts ...grpc.CallOption) (*access.AccountBalanceResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetAccountBalanceAtLatestBlock", varargs...) @@ -195,17 +196,17 @@ func (m *MockAccessAPIClient) GetAccountBalanceAtLatestBlock(arg0 context.Contex } // GetAccountBalanceAtLatestBlock indicates an expected call of GetAccountBalanceAtLatestBlock. -func (mr *MockAccessAPIClientMockRecorder) GetAccountBalanceAtLatestBlock(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetAccountBalanceAtLatestBlock(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountBalanceAtLatestBlock", reflect.TypeOf((*MockAccessAPIClient)(nil).GetAccountBalanceAtLatestBlock), varargs...) } // GetAccountKeyAtBlockHeight mocks base method. -func (m *MockAccessAPIClient) GetAccountKeyAtBlockHeight(arg0 context.Context, arg1 *access.GetAccountKeyAtBlockHeightRequest, arg2 ...grpc.CallOption) (*access.AccountKeyResponse, error) { +func (m *MockAccessAPIClient) GetAccountKeyAtBlockHeight(ctx context.Context, in *access.GetAccountKeyAtBlockHeightRequest, opts ...grpc.CallOption) (*access.AccountKeyResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetAccountKeyAtBlockHeight", varargs...) @@ -215,17 +216,17 @@ func (m *MockAccessAPIClient) GetAccountKeyAtBlockHeight(arg0 context.Context, a } // GetAccountKeyAtBlockHeight indicates an expected call of GetAccountKeyAtBlockHeight. -func (mr *MockAccessAPIClientMockRecorder) GetAccountKeyAtBlockHeight(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetAccountKeyAtBlockHeight(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountKeyAtBlockHeight", reflect.TypeOf((*MockAccessAPIClient)(nil).GetAccountKeyAtBlockHeight), varargs...) } // GetAccountKeyAtLatestBlock mocks base method. -func (m *MockAccessAPIClient) GetAccountKeyAtLatestBlock(arg0 context.Context, arg1 *access.GetAccountKeyAtLatestBlockRequest, arg2 ...grpc.CallOption) (*access.AccountKeyResponse, error) { +func (m *MockAccessAPIClient) GetAccountKeyAtLatestBlock(ctx context.Context, in *access.GetAccountKeyAtLatestBlockRequest, opts ...grpc.CallOption) (*access.AccountKeyResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetAccountKeyAtLatestBlock", varargs...) @@ -235,17 +236,17 @@ func (m *MockAccessAPIClient) GetAccountKeyAtLatestBlock(arg0 context.Context, a } // GetAccountKeyAtLatestBlock indicates an expected call of GetAccountKeyAtLatestBlock. -func (mr *MockAccessAPIClientMockRecorder) GetAccountKeyAtLatestBlock(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetAccountKeyAtLatestBlock(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountKeyAtLatestBlock", reflect.TypeOf((*MockAccessAPIClient)(nil).GetAccountKeyAtLatestBlock), varargs...) } // GetAccountKeysAtBlockHeight mocks base method. -func (m *MockAccessAPIClient) GetAccountKeysAtBlockHeight(arg0 context.Context, arg1 *access.GetAccountKeysAtBlockHeightRequest, arg2 ...grpc.CallOption) (*access.AccountKeysResponse, error) { +func (m *MockAccessAPIClient) GetAccountKeysAtBlockHeight(ctx context.Context, in *access.GetAccountKeysAtBlockHeightRequest, opts ...grpc.CallOption) (*access.AccountKeysResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetAccountKeysAtBlockHeight", varargs...) @@ -255,17 +256,17 @@ func (m *MockAccessAPIClient) GetAccountKeysAtBlockHeight(arg0 context.Context, } // GetAccountKeysAtBlockHeight indicates an expected call of GetAccountKeysAtBlockHeight. -func (mr *MockAccessAPIClientMockRecorder) GetAccountKeysAtBlockHeight(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetAccountKeysAtBlockHeight(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountKeysAtBlockHeight", reflect.TypeOf((*MockAccessAPIClient)(nil).GetAccountKeysAtBlockHeight), varargs...) } // GetAccountKeysAtLatestBlock mocks base method. -func (m *MockAccessAPIClient) GetAccountKeysAtLatestBlock(arg0 context.Context, arg1 *access.GetAccountKeysAtLatestBlockRequest, arg2 ...grpc.CallOption) (*access.AccountKeysResponse, error) { +func (m *MockAccessAPIClient) GetAccountKeysAtLatestBlock(ctx context.Context, in *access.GetAccountKeysAtLatestBlockRequest, opts ...grpc.CallOption) (*access.AccountKeysResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetAccountKeysAtLatestBlock", varargs...) @@ -275,17 +276,17 @@ func (m *MockAccessAPIClient) GetAccountKeysAtLatestBlock(arg0 context.Context, } // GetAccountKeysAtLatestBlock indicates an expected call of GetAccountKeysAtLatestBlock. -func (mr *MockAccessAPIClientMockRecorder) GetAccountKeysAtLatestBlock(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetAccountKeysAtLatestBlock(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountKeysAtLatestBlock", reflect.TypeOf((*MockAccessAPIClient)(nil).GetAccountKeysAtLatestBlock), varargs...) } // GetBlockByHeight mocks base method. -func (m *MockAccessAPIClient) GetBlockByHeight(arg0 context.Context, arg1 *access.GetBlockByHeightRequest, arg2 ...grpc.CallOption) (*access.BlockResponse, error) { +func (m *MockAccessAPIClient) GetBlockByHeight(ctx context.Context, in *access.GetBlockByHeightRequest, opts ...grpc.CallOption) (*access.BlockResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetBlockByHeight", varargs...) @@ -295,17 +296,17 @@ func (m *MockAccessAPIClient) GetBlockByHeight(arg0 context.Context, arg1 *acces } // GetBlockByHeight indicates an expected call of GetBlockByHeight. -func (mr *MockAccessAPIClientMockRecorder) GetBlockByHeight(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetBlockByHeight(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockByHeight", reflect.TypeOf((*MockAccessAPIClient)(nil).GetBlockByHeight), varargs...) } // GetBlockByID mocks base method. -func (m *MockAccessAPIClient) GetBlockByID(arg0 context.Context, arg1 *access.GetBlockByIDRequest, arg2 ...grpc.CallOption) (*access.BlockResponse, error) { +func (m *MockAccessAPIClient) GetBlockByID(ctx context.Context, in *access.GetBlockByIDRequest, opts ...grpc.CallOption) (*access.BlockResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetBlockByID", varargs...) @@ -315,17 +316,17 @@ func (m *MockAccessAPIClient) GetBlockByID(arg0 context.Context, arg1 *access.Ge } // GetBlockByID indicates an expected call of GetBlockByID. -func (mr *MockAccessAPIClientMockRecorder) GetBlockByID(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetBlockByID(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockByID", reflect.TypeOf((*MockAccessAPIClient)(nil).GetBlockByID), varargs...) } // GetBlockHeaderByHeight mocks base method. -func (m *MockAccessAPIClient) GetBlockHeaderByHeight(arg0 context.Context, arg1 *access.GetBlockHeaderByHeightRequest, arg2 ...grpc.CallOption) (*access.BlockHeaderResponse, error) { +func (m *MockAccessAPIClient) GetBlockHeaderByHeight(ctx context.Context, in *access.GetBlockHeaderByHeightRequest, opts ...grpc.CallOption) (*access.BlockHeaderResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetBlockHeaderByHeight", varargs...) @@ -335,17 +336,17 @@ func (m *MockAccessAPIClient) GetBlockHeaderByHeight(arg0 context.Context, arg1 } // GetBlockHeaderByHeight indicates an expected call of GetBlockHeaderByHeight. -func (mr *MockAccessAPIClientMockRecorder) GetBlockHeaderByHeight(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetBlockHeaderByHeight(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockHeaderByHeight", reflect.TypeOf((*MockAccessAPIClient)(nil).GetBlockHeaderByHeight), varargs...) } // GetBlockHeaderByID mocks base method. -func (m *MockAccessAPIClient) GetBlockHeaderByID(arg0 context.Context, arg1 *access.GetBlockHeaderByIDRequest, arg2 ...grpc.CallOption) (*access.BlockHeaderResponse, error) { +func (m *MockAccessAPIClient) GetBlockHeaderByID(ctx context.Context, in *access.GetBlockHeaderByIDRequest, opts ...grpc.CallOption) (*access.BlockHeaderResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetBlockHeaderByID", varargs...) @@ -355,17 +356,17 @@ func (m *MockAccessAPIClient) GetBlockHeaderByID(arg0 context.Context, arg1 *acc } // GetBlockHeaderByID indicates an expected call of GetBlockHeaderByID. -func (mr *MockAccessAPIClientMockRecorder) GetBlockHeaderByID(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetBlockHeaderByID(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockHeaderByID", reflect.TypeOf((*MockAccessAPIClient)(nil).GetBlockHeaderByID), varargs...) } // GetCollectionByID mocks base method. -func (m *MockAccessAPIClient) GetCollectionByID(arg0 context.Context, arg1 *access.GetCollectionByIDRequest, arg2 ...grpc.CallOption) (*access.CollectionResponse, error) { +func (m *MockAccessAPIClient) GetCollectionByID(ctx context.Context, in *access.GetCollectionByIDRequest, opts ...grpc.CallOption) (*access.CollectionResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetCollectionByID", varargs...) @@ -375,17 +376,17 @@ func (m *MockAccessAPIClient) GetCollectionByID(arg0 context.Context, arg1 *acce } // GetCollectionByID indicates an expected call of GetCollectionByID. -func (mr *MockAccessAPIClientMockRecorder) GetCollectionByID(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetCollectionByID(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCollectionByID", reflect.TypeOf((*MockAccessAPIClient)(nil).GetCollectionByID), varargs...) } // GetEventsForBlockIDs mocks base method. -func (m *MockAccessAPIClient) GetEventsForBlockIDs(arg0 context.Context, arg1 *access.GetEventsForBlockIDsRequest, arg2 ...grpc.CallOption) (*access.EventsResponse, error) { +func (m *MockAccessAPIClient) GetEventsForBlockIDs(ctx context.Context, in *access.GetEventsForBlockIDsRequest, opts ...grpc.CallOption) (*access.EventsResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetEventsForBlockIDs", varargs...) @@ -395,17 +396,17 @@ func (m *MockAccessAPIClient) GetEventsForBlockIDs(arg0 context.Context, arg1 *a } // GetEventsForBlockIDs indicates an expected call of GetEventsForBlockIDs. -func (mr *MockAccessAPIClientMockRecorder) GetEventsForBlockIDs(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetEventsForBlockIDs(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEventsForBlockIDs", reflect.TypeOf((*MockAccessAPIClient)(nil).GetEventsForBlockIDs), varargs...) } // GetEventsForHeightRange mocks base method. -func (m *MockAccessAPIClient) GetEventsForHeightRange(arg0 context.Context, arg1 *access.GetEventsForHeightRangeRequest, arg2 ...grpc.CallOption) (*access.EventsResponse, error) { +func (m *MockAccessAPIClient) GetEventsForHeightRange(ctx context.Context, in *access.GetEventsForHeightRangeRequest, opts ...grpc.CallOption) (*access.EventsResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetEventsForHeightRange", varargs...) @@ -415,17 +416,17 @@ func (m *MockAccessAPIClient) GetEventsForHeightRange(arg0 context.Context, arg1 } // GetEventsForHeightRange indicates an expected call of GetEventsForHeightRange. -func (mr *MockAccessAPIClientMockRecorder) GetEventsForHeightRange(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetEventsForHeightRange(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEventsForHeightRange", reflect.TypeOf((*MockAccessAPIClient)(nil).GetEventsForHeightRange), varargs...) } // GetExecutionResultByID mocks base method. -func (m *MockAccessAPIClient) GetExecutionResultByID(arg0 context.Context, arg1 *access.GetExecutionResultByIDRequest, arg2 ...grpc.CallOption) (*access.ExecutionResultByIDResponse, error) { +func (m *MockAccessAPIClient) GetExecutionResultByID(ctx context.Context, in *access.GetExecutionResultByIDRequest, opts ...grpc.CallOption) (*access.ExecutionResultByIDResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetExecutionResultByID", varargs...) @@ -435,17 +436,17 @@ func (m *MockAccessAPIClient) GetExecutionResultByID(arg0 context.Context, arg1 } // GetExecutionResultByID indicates an expected call of GetExecutionResultByID. -func (mr *MockAccessAPIClientMockRecorder) GetExecutionResultByID(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetExecutionResultByID(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExecutionResultByID", reflect.TypeOf((*MockAccessAPIClient)(nil).GetExecutionResultByID), varargs...) } // GetExecutionResultForBlockID mocks base method. -func (m *MockAccessAPIClient) GetExecutionResultForBlockID(arg0 context.Context, arg1 *access.GetExecutionResultForBlockIDRequest, arg2 ...grpc.CallOption) (*access.ExecutionResultForBlockIDResponse, error) { +func (m *MockAccessAPIClient) GetExecutionResultForBlockID(ctx context.Context, in *access.GetExecutionResultForBlockIDRequest, opts ...grpc.CallOption) (*access.ExecutionResultForBlockIDResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetExecutionResultForBlockID", varargs...) @@ -455,17 +456,17 @@ func (m *MockAccessAPIClient) GetExecutionResultForBlockID(arg0 context.Context, } // GetExecutionResultForBlockID indicates an expected call of GetExecutionResultForBlockID. -func (mr *MockAccessAPIClientMockRecorder) GetExecutionResultForBlockID(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetExecutionResultForBlockID(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExecutionResultForBlockID", reflect.TypeOf((*MockAccessAPIClient)(nil).GetExecutionResultForBlockID), varargs...) } // GetFullCollectionByID mocks base method. -func (m *MockAccessAPIClient) GetFullCollectionByID(arg0 context.Context, arg1 *access.GetFullCollectionByIDRequest, arg2 ...grpc.CallOption) (*access.FullCollectionResponse, error) { +func (m *MockAccessAPIClient) GetFullCollectionByID(ctx context.Context, in *access.GetFullCollectionByIDRequest, opts ...grpc.CallOption) (*access.FullCollectionResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetFullCollectionByID", varargs...) @@ -475,17 +476,17 @@ func (m *MockAccessAPIClient) GetFullCollectionByID(arg0 context.Context, arg1 * } // GetFullCollectionByID indicates an expected call of GetFullCollectionByID. -func (mr *MockAccessAPIClientMockRecorder) GetFullCollectionByID(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetFullCollectionByID(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFullCollectionByID", reflect.TypeOf((*MockAccessAPIClient)(nil).GetFullCollectionByID), varargs...) } // GetLatestBlock mocks base method. -func (m *MockAccessAPIClient) GetLatestBlock(arg0 context.Context, arg1 *access.GetLatestBlockRequest, arg2 ...grpc.CallOption) (*access.BlockResponse, error) { +func (m *MockAccessAPIClient) GetLatestBlock(ctx context.Context, in *access.GetLatestBlockRequest, opts ...grpc.CallOption) (*access.BlockResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetLatestBlock", varargs...) @@ -495,17 +496,17 @@ func (m *MockAccessAPIClient) GetLatestBlock(arg0 context.Context, arg1 *access. } // GetLatestBlock indicates an expected call of GetLatestBlock. -func (mr *MockAccessAPIClientMockRecorder) GetLatestBlock(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetLatestBlock(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestBlock", reflect.TypeOf((*MockAccessAPIClient)(nil).GetLatestBlock), varargs...) } // GetLatestBlockHeader mocks base method. -func (m *MockAccessAPIClient) GetLatestBlockHeader(arg0 context.Context, arg1 *access.GetLatestBlockHeaderRequest, arg2 ...grpc.CallOption) (*access.BlockHeaderResponse, error) { +func (m *MockAccessAPIClient) GetLatestBlockHeader(ctx context.Context, in *access.GetLatestBlockHeaderRequest, opts ...grpc.CallOption) (*access.BlockHeaderResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetLatestBlockHeader", varargs...) @@ -515,17 +516,17 @@ func (m *MockAccessAPIClient) GetLatestBlockHeader(arg0 context.Context, arg1 *a } // GetLatestBlockHeader indicates an expected call of GetLatestBlockHeader. -func (mr *MockAccessAPIClientMockRecorder) GetLatestBlockHeader(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetLatestBlockHeader(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestBlockHeader", reflect.TypeOf((*MockAccessAPIClient)(nil).GetLatestBlockHeader), varargs...) } // GetLatestProtocolStateSnapshot mocks base method. -func (m *MockAccessAPIClient) GetLatestProtocolStateSnapshot(arg0 context.Context, arg1 *access.GetLatestProtocolStateSnapshotRequest, arg2 ...grpc.CallOption) (*access.ProtocolStateSnapshotResponse, error) { +func (m *MockAccessAPIClient) GetLatestProtocolStateSnapshot(ctx context.Context, in *access.GetLatestProtocolStateSnapshotRequest, opts ...grpc.CallOption) (*access.ProtocolStateSnapshotResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetLatestProtocolStateSnapshot", varargs...) @@ -535,17 +536,17 @@ func (m *MockAccessAPIClient) GetLatestProtocolStateSnapshot(arg0 context.Contex } // GetLatestProtocolStateSnapshot indicates an expected call of GetLatestProtocolStateSnapshot. -func (mr *MockAccessAPIClientMockRecorder) GetLatestProtocolStateSnapshot(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetLatestProtocolStateSnapshot(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestProtocolStateSnapshot", reflect.TypeOf((*MockAccessAPIClient)(nil).GetLatestProtocolStateSnapshot), varargs...) } // GetNetworkParameters mocks base method. -func (m *MockAccessAPIClient) GetNetworkParameters(arg0 context.Context, arg1 *access.GetNetworkParametersRequest, arg2 ...grpc.CallOption) (*access.GetNetworkParametersResponse, error) { +func (m *MockAccessAPIClient) GetNetworkParameters(ctx context.Context, in *access.GetNetworkParametersRequest, opts ...grpc.CallOption) (*access.GetNetworkParametersResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetNetworkParameters", varargs...) @@ -555,17 +556,17 @@ func (m *MockAccessAPIClient) GetNetworkParameters(arg0 context.Context, arg1 *a } // GetNetworkParameters indicates an expected call of GetNetworkParameters. -func (mr *MockAccessAPIClientMockRecorder) GetNetworkParameters(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetNetworkParameters(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkParameters", reflect.TypeOf((*MockAccessAPIClient)(nil).GetNetworkParameters), varargs...) } // GetNodeVersionInfo mocks base method. -func (m *MockAccessAPIClient) GetNodeVersionInfo(arg0 context.Context, arg1 *access.GetNodeVersionInfoRequest, arg2 ...grpc.CallOption) (*access.GetNodeVersionInfoResponse, error) { +func (m *MockAccessAPIClient) GetNodeVersionInfo(ctx context.Context, in *access.GetNodeVersionInfoRequest, opts ...grpc.CallOption) (*access.GetNodeVersionInfoResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetNodeVersionInfo", varargs...) @@ -575,17 +576,17 @@ func (m *MockAccessAPIClient) GetNodeVersionInfo(arg0 context.Context, arg1 *acc } // GetNodeVersionInfo indicates an expected call of GetNodeVersionInfo. -func (mr *MockAccessAPIClientMockRecorder) GetNodeVersionInfo(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetNodeVersionInfo(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeVersionInfo", reflect.TypeOf((*MockAccessAPIClient)(nil).GetNodeVersionInfo), varargs...) } // GetProtocolStateSnapshotByBlockID mocks base method. -func (m *MockAccessAPIClient) GetProtocolStateSnapshotByBlockID(arg0 context.Context, arg1 *access.GetProtocolStateSnapshotByBlockIDRequest, arg2 ...grpc.CallOption) (*access.ProtocolStateSnapshotResponse, error) { +func (m *MockAccessAPIClient) GetProtocolStateSnapshotByBlockID(ctx context.Context, in *access.GetProtocolStateSnapshotByBlockIDRequest, opts ...grpc.CallOption) (*access.ProtocolStateSnapshotResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetProtocolStateSnapshotByBlockID", varargs...) @@ -595,17 +596,17 @@ func (m *MockAccessAPIClient) GetProtocolStateSnapshotByBlockID(arg0 context.Con } // GetProtocolStateSnapshotByBlockID indicates an expected call of GetProtocolStateSnapshotByBlockID. -func (mr *MockAccessAPIClientMockRecorder) GetProtocolStateSnapshotByBlockID(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetProtocolStateSnapshotByBlockID(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProtocolStateSnapshotByBlockID", reflect.TypeOf((*MockAccessAPIClient)(nil).GetProtocolStateSnapshotByBlockID), varargs...) } // GetProtocolStateSnapshotByHeight mocks base method. -func (m *MockAccessAPIClient) GetProtocolStateSnapshotByHeight(arg0 context.Context, arg1 *access.GetProtocolStateSnapshotByHeightRequest, arg2 ...grpc.CallOption) (*access.ProtocolStateSnapshotResponse, error) { +func (m *MockAccessAPIClient) GetProtocolStateSnapshotByHeight(ctx context.Context, in *access.GetProtocolStateSnapshotByHeightRequest, opts ...grpc.CallOption) (*access.ProtocolStateSnapshotResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetProtocolStateSnapshotByHeight", varargs...) @@ -615,17 +616,17 @@ func (m *MockAccessAPIClient) GetProtocolStateSnapshotByHeight(arg0 context.Cont } // GetProtocolStateSnapshotByHeight indicates an expected call of GetProtocolStateSnapshotByHeight. -func (mr *MockAccessAPIClientMockRecorder) GetProtocolStateSnapshotByHeight(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetProtocolStateSnapshotByHeight(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProtocolStateSnapshotByHeight", reflect.TypeOf((*MockAccessAPIClient)(nil).GetProtocolStateSnapshotByHeight), varargs...) } // GetSystemTransaction mocks base method. -func (m *MockAccessAPIClient) GetSystemTransaction(arg0 context.Context, arg1 *access.GetSystemTransactionRequest, arg2 ...grpc.CallOption) (*access.TransactionResponse, error) { +func (m *MockAccessAPIClient) GetSystemTransaction(ctx context.Context, in *access.GetSystemTransactionRequest, opts ...grpc.CallOption) (*access.TransactionResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetSystemTransaction", varargs...) @@ -635,17 +636,17 @@ func (m *MockAccessAPIClient) GetSystemTransaction(arg0 context.Context, arg1 *a } // GetSystemTransaction indicates an expected call of GetSystemTransaction. -func (mr *MockAccessAPIClientMockRecorder) GetSystemTransaction(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetSystemTransaction(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSystemTransaction", reflect.TypeOf((*MockAccessAPIClient)(nil).GetSystemTransaction), varargs...) } // GetSystemTransactionResult mocks base method. -func (m *MockAccessAPIClient) GetSystemTransactionResult(arg0 context.Context, arg1 *access.GetSystemTransactionResultRequest, arg2 ...grpc.CallOption) (*access.TransactionResultResponse, error) { +func (m *MockAccessAPIClient) GetSystemTransactionResult(ctx context.Context, in *access.GetSystemTransactionResultRequest, opts ...grpc.CallOption) (*access.TransactionResultResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetSystemTransactionResult", varargs...) @@ -655,17 +656,17 @@ func (m *MockAccessAPIClient) GetSystemTransactionResult(arg0 context.Context, a } // GetSystemTransactionResult indicates an expected call of GetSystemTransactionResult. -func (mr *MockAccessAPIClientMockRecorder) GetSystemTransactionResult(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetSystemTransactionResult(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSystemTransactionResult", reflect.TypeOf((*MockAccessAPIClient)(nil).GetSystemTransactionResult), varargs...) } // GetTransaction mocks base method. -func (m *MockAccessAPIClient) GetTransaction(arg0 context.Context, arg1 *access.GetTransactionRequest, arg2 ...grpc.CallOption) (*access.TransactionResponse, error) { +func (m *MockAccessAPIClient) GetTransaction(ctx context.Context, in *access.GetTransactionRequest, opts ...grpc.CallOption) (*access.TransactionResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetTransaction", varargs...) @@ -675,17 +676,17 @@ func (m *MockAccessAPIClient) GetTransaction(arg0 context.Context, arg1 *access. } // GetTransaction indicates an expected call of GetTransaction. -func (mr *MockAccessAPIClientMockRecorder) GetTransaction(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetTransaction(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransaction", reflect.TypeOf((*MockAccessAPIClient)(nil).GetTransaction), varargs...) } // GetTransactionResult mocks base method. -func (m *MockAccessAPIClient) GetTransactionResult(arg0 context.Context, arg1 *access.GetTransactionRequest, arg2 ...grpc.CallOption) (*access.TransactionResultResponse, error) { +func (m *MockAccessAPIClient) GetTransactionResult(ctx context.Context, in *access.GetTransactionRequest, opts ...grpc.CallOption) (*access.TransactionResultResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetTransactionResult", varargs...) @@ -695,17 +696,17 @@ func (m *MockAccessAPIClient) GetTransactionResult(arg0 context.Context, arg1 *a } // GetTransactionResult indicates an expected call of GetTransactionResult. -func (mr *MockAccessAPIClientMockRecorder) GetTransactionResult(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetTransactionResult(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransactionResult", reflect.TypeOf((*MockAccessAPIClient)(nil).GetTransactionResult), varargs...) } // GetTransactionResultByIndex mocks base method. -func (m *MockAccessAPIClient) GetTransactionResultByIndex(arg0 context.Context, arg1 *access.GetTransactionByIndexRequest, arg2 ...grpc.CallOption) (*access.TransactionResultResponse, error) { +func (m *MockAccessAPIClient) GetTransactionResultByIndex(ctx context.Context, in *access.GetTransactionByIndexRequest, opts ...grpc.CallOption) (*access.TransactionResultResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetTransactionResultByIndex", varargs...) @@ -715,17 +716,17 @@ func (m *MockAccessAPIClient) GetTransactionResultByIndex(arg0 context.Context, } // GetTransactionResultByIndex indicates an expected call of GetTransactionResultByIndex. -func (mr *MockAccessAPIClientMockRecorder) GetTransactionResultByIndex(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetTransactionResultByIndex(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransactionResultByIndex", reflect.TypeOf((*MockAccessAPIClient)(nil).GetTransactionResultByIndex), varargs...) } // GetTransactionResultsByBlockID mocks base method. -func (m *MockAccessAPIClient) GetTransactionResultsByBlockID(arg0 context.Context, arg1 *access.GetTransactionsByBlockIDRequest, arg2 ...grpc.CallOption) (*access.TransactionResultsResponse, error) { +func (m *MockAccessAPIClient) GetTransactionResultsByBlockID(ctx context.Context, in *access.GetTransactionsByBlockIDRequest, opts ...grpc.CallOption) (*access.TransactionResultsResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetTransactionResultsByBlockID", varargs...) @@ -735,17 +736,17 @@ func (m *MockAccessAPIClient) GetTransactionResultsByBlockID(arg0 context.Contex } // GetTransactionResultsByBlockID indicates an expected call of GetTransactionResultsByBlockID. -func (mr *MockAccessAPIClientMockRecorder) GetTransactionResultsByBlockID(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetTransactionResultsByBlockID(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransactionResultsByBlockID", reflect.TypeOf((*MockAccessAPIClient)(nil).GetTransactionResultsByBlockID), varargs...) } // GetTransactionsByBlockID mocks base method. -func (m *MockAccessAPIClient) GetTransactionsByBlockID(arg0 context.Context, arg1 *access.GetTransactionsByBlockIDRequest, arg2 ...grpc.CallOption) (*access.TransactionsResponse, error) { +func (m *MockAccessAPIClient) GetTransactionsByBlockID(ctx context.Context, in *access.GetTransactionsByBlockIDRequest, opts ...grpc.CallOption) (*access.TransactionsResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetTransactionsByBlockID", varargs...) @@ -755,17 +756,17 @@ func (m *MockAccessAPIClient) GetTransactionsByBlockID(arg0 context.Context, arg } // GetTransactionsByBlockID indicates an expected call of GetTransactionsByBlockID. -func (mr *MockAccessAPIClientMockRecorder) GetTransactionsByBlockID(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) GetTransactionsByBlockID(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransactionsByBlockID", reflect.TypeOf((*MockAccessAPIClient)(nil).GetTransactionsByBlockID), varargs...) } // Ping mocks base method. -func (m *MockAccessAPIClient) Ping(arg0 context.Context, arg1 *access.PingRequest, arg2 ...grpc.CallOption) (*access.PingResponse, error) { +func (m *MockAccessAPIClient) Ping(ctx context.Context, in *access.PingRequest, opts ...grpc.CallOption) (*access.PingResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Ping", varargs...) @@ -775,17 +776,17 @@ func (m *MockAccessAPIClient) Ping(arg0 context.Context, arg1 *access.PingReques } // Ping indicates an expected call of Ping. -func (mr *MockAccessAPIClientMockRecorder) Ping(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) Ping(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockAccessAPIClient)(nil).Ping), varargs...) } // SendAndSubscribeTransactionStatuses mocks base method. -func (m *MockAccessAPIClient) SendAndSubscribeTransactionStatuses(arg0 context.Context, arg1 *access.SendAndSubscribeTransactionStatusesRequest, arg2 ...grpc.CallOption) (access.AccessAPI_SendAndSubscribeTransactionStatusesClient, error) { +func (m *MockAccessAPIClient) SendAndSubscribeTransactionStatuses(ctx context.Context, in *access.SendAndSubscribeTransactionStatusesRequest, opts ...grpc.CallOption) (access.AccessAPI_SendAndSubscribeTransactionStatusesClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SendAndSubscribeTransactionStatuses", varargs...) @@ -795,17 +796,17 @@ func (m *MockAccessAPIClient) SendAndSubscribeTransactionStatuses(arg0 context.C } // SendAndSubscribeTransactionStatuses indicates an expected call of SendAndSubscribeTransactionStatuses. -func (mr *MockAccessAPIClientMockRecorder) SendAndSubscribeTransactionStatuses(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) SendAndSubscribeTransactionStatuses(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAndSubscribeTransactionStatuses", reflect.TypeOf((*MockAccessAPIClient)(nil).SendAndSubscribeTransactionStatuses), varargs...) } // SendTransaction mocks base method. -func (m *MockAccessAPIClient) SendTransaction(arg0 context.Context, arg1 *access.SendTransactionRequest, arg2 ...grpc.CallOption) (*access.SendTransactionResponse, error) { +func (m *MockAccessAPIClient) SendTransaction(ctx context.Context, in *access.SendTransactionRequest, opts ...grpc.CallOption) (*access.SendTransactionResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SendTransaction", varargs...) @@ -815,17 +816,17 @@ func (m *MockAccessAPIClient) SendTransaction(arg0 context.Context, arg1 *access } // SendTransaction indicates an expected call of SendTransaction. -func (mr *MockAccessAPIClientMockRecorder) SendTransaction(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) SendTransaction(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTransaction", reflect.TypeOf((*MockAccessAPIClient)(nil).SendTransaction), varargs...) } // SubscribeBlockDigestsFromLatest mocks base method. -func (m *MockAccessAPIClient) SubscribeBlockDigestsFromLatest(arg0 context.Context, arg1 *access.SubscribeBlockDigestsFromLatestRequest, arg2 ...grpc.CallOption) (access.AccessAPI_SubscribeBlockDigestsFromLatestClient, error) { +func (m *MockAccessAPIClient) SubscribeBlockDigestsFromLatest(ctx context.Context, in *access.SubscribeBlockDigestsFromLatestRequest, opts ...grpc.CallOption) (access.AccessAPI_SubscribeBlockDigestsFromLatestClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeBlockDigestsFromLatest", varargs...) @@ -835,17 +836,17 @@ func (m *MockAccessAPIClient) SubscribeBlockDigestsFromLatest(arg0 context.Conte } // SubscribeBlockDigestsFromLatest indicates an expected call of SubscribeBlockDigestsFromLatest. -func (mr *MockAccessAPIClientMockRecorder) SubscribeBlockDigestsFromLatest(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) SubscribeBlockDigestsFromLatest(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeBlockDigestsFromLatest", reflect.TypeOf((*MockAccessAPIClient)(nil).SubscribeBlockDigestsFromLatest), varargs...) } // SubscribeBlockDigestsFromStartBlockID mocks base method. -func (m *MockAccessAPIClient) SubscribeBlockDigestsFromStartBlockID(arg0 context.Context, arg1 *access.SubscribeBlockDigestsFromStartBlockIDRequest, arg2 ...grpc.CallOption) (access.AccessAPI_SubscribeBlockDigestsFromStartBlockIDClient, error) { +func (m *MockAccessAPIClient) SubscribeBlockDigestsFromStartBlockID(ctx context.Context, in *access.SubscribeBlockDigestsFromStartBlockIDRequest, opts ...grpc.CallOption) (access.AccessAPI_SubscribeBlockDigestsFromStartBlockIDClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeBlockDigestsFromStartBlockID", varargs...) @@ -855,17 +856,17 @@ func (m *MockAccessAPIClient) SubscribeBlockDigestsFromStartBlockID(arg0 context } // SubscribeBlockDigestsFromStartBlockID indicates an expected call of SubscribeBlockDigestsFromStartBlockID. -func (mr *MockAccessAPIClientMockRecorder) SubscribeBlockDigestsFromStartBlockID(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) SubscribeBlockDigestsFromStartBlockID(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeBlockDigestsFromStartBlockID", reflect.TypeOf((*MockAccessAPIClient)(nil).SubscribeBlockDigestsFromStartBlockID), varargs...) } // SubscribeBlockDigestsFromStartHeight mocks base method. -func (m *MockAccessAPIClient) SubscribeBlockDigestsFromStartHeight(arg0 context.Context, arg1 *access.SubscribeBlockDigestsFromStartHeightRequest, arg2 ...grpc.CallOption) (access.AccessAPI_SubscribeBlockDigestsFromStartHeightClient, error) { +func (m *MockAccessAPIClient) SubscribeBlockDigestsFromStartHeight(ctx context.Context, in *access.SubscribeBlockDigestsFromStartHeightRequest, opts ...grpc.CallOption) (access.AccessAPI_SubscribeBlockDigestsFromStartHeightClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeBlockDigestsFromStartHeight", varargs...) @@ -875,17 +876,17 @@ func (m *MockAccessAPIClient) SubscribeBlockDigestsFromStartHeight(arg0 context. } // SubscribeBlockDigestsFromStartHeight indicates an expected call of SubscribeBlockDigestsFromStartHeight. -func (mr *MockAccessAPIClientMockRecorder) SubscribeBlockDigestsFromStartHeight(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) SubscribeBlockDigestsFromStartHeight(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeBlockDigestsFromStartHeight", reflect.TypeOf((*MockAccessAPIClient)(nil).SubscribeBlockDigestsFromStartHeight), varargs...) } // SubscribeBlockHeadersFromLatest mocks base method. -func (m *MockAccessAPIClient) SubscribeBlockHeadersFromLatest(arg0 context.Context, arg1 *access.SubscribeBlockHeadersFromLatestRequest, arg2 ...grpc.CallOption) (access.AccessAPI_SubscribeBlockHeadersFromLatestClient, error) { +func (m *MockAccessAPIClient) SubscribeBlockHeadersFromLatest(ctx context.Context, in *access.SubscribeBlockHeadersFromLatestRequest, opts ...grpc.CallOption) (access.AccessAPI_SubscribeBlockHeadersFromLatestClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeBlockHeadersFromLatest", varargs...) @@ -895,17 +896,17 @@ func (m *MockAccessAPIClient) SubscribeBlockHeadersFromLatest(arg0 context.Conte } // SubscribeBlockHeadersFromLatest indicates an expected call of SubscribeBlockHeadersFromLatest. -func (mr *MockAccessAPIClientMockRecorder) SubscribeBlockHeadersFromLatest(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) SubscribeBlockHeadersFromLatest(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeBlockHeadersFromLatest", reflect.TypeOf((*MockAccessAPIClient)(nil).SubscribeBlockHeadersFromLatest), varargs...) } // SubscribeBlockHeadersFromStartBlockID mocks base method. -func (m *MockAccessAPIClient) SubscribeBlockHeadersFromStartBlockID(arg0 context.Context, arg1 *access.SubscribeBlockHeadersFromStartBlockIDRequest, arg2 ...grpc.CallOption) (access.AccessAPI_SubscribeBlockHeadersFromStartBlockIDClient, error) { +func (m *MockAccessAPIClient) SubscribeBlockHeadersFromStartBlockID(ctx context.Context, in *access.SubscribeBlockHeadersFromStartBlockIDRequest, opts ...grpc.CallOption) (access.AccessAPI_SubscribeBlockHeadersFromStartBlockIDClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeBlockHeadersFromStartBlockID", varargs...) @@ -915,17 +916,17 @@ func (m *MockAccessAPIClient) SubscribeBlockHeadersFromStartBlockID(arg0 context } // SubscribeBlockHeadersFromStartBlockID indicates an expected call of SubscribeBlockHeadersFromStartBlockID. -func (mr *MockAccessAPIClientMockRecorder) SubscribeBlockHeadersFromStartBlockID(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) SubscribeBlockHeadersFromStartBlockID(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeBlockHeadersFromStartBlockID", reflect.TypeOf((*MockAccessAPIClient)(nil).SubscribeBlockHeadersFromStartBlockID), varargs...) } // SubscribeBlockHeadersFromStartHeight mocks base method. -func (m *MockAccessAPIClient) SubscribeBlockHeadersFromStartHeight(arg0 context.Context, arg1 *access.SubscribeBlockHeadersFromStartHeightRequest, arg2 ...grpc.CallOption) (access.AccessAPI_SubscribeBlockHeadersFromStartHeightClient, error) { +func (m *MockAccessAPIClient) SubscribeBlockHeadersFromStartHeight(ctx context.Context, in *access.SubscribeBlockHeadersFromStartHeightRequest, opts ...grpc.CallOption) (access.AccessAPI_SubscribeBlockHeadersFromStartHeightClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeBlockHeadersFromStartHeight", varargs...) @@ -935,17 +936,17 @@ func (m *MockAccessAPIClient) SubscribeBlockHeadersFromStartHeight(arg0 context. } // SubscribeBlockHeadersFromStartHeight indicates an expected call of SubscribeBlockHeadersFromStartHeight. -func (mr *MockAccessAPIClientMockRecorder) SubscribeBlockHeadersFromStartHeight(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) SubscribeBlockHeadersFromStartHeight(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeBlockHeadersFromStartHeight", reflect.TypeOf((*MockAccessAPIClient)(nil).SubscribeBlockHeadersFromStartHeight), varargs...) } // SubscribeBlocksFromLatest mocks base method. -func (m *MockAccessAPIClient) SubscribeBlocksFromLatest(arg0 context.Context, arg1 *access.SubscribeBlocksFromLatestRequest, arg2 ...grpc.CallOption) (access.AccessAPI_SubscribeBlocksFromLatestClient, error) { +func (m *MockAccessAPIClient) SubscribeBlocksFromLatest(ctx context.Context, in *access.SubscribeBlocksFromLatestRequest, opts ...grpc.CallOption) (access.AccessAPI_SubscribeBlocksFromLatestClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeBlocksFromLatest", varargs...) @@ -955,17 +956,17 @@ func (m *MockAccessAPIClient) SubscribeBlocksFromLatest(arg0 context.Context, ar } // SubscribeBlocksFromLatest indicates an expected call of SubscribeBlocksFromLatest. -func (mr *MockAccessAPIClientMockRecorder) SubscribeBlocksFromLatest(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) SubscribeBlocksFromLatest(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeBlocksFromLatest", reflect.TypeOf((*MockAccessAPIClient)(nil).SubscribeBlocksFromLatest), varargs...) } // SubscribeBlocksFromStartBlockID mocks base method. -func (m *MockAccessAPIClient) SubscribeBlocksFromStartBlockID(arg0 context.Context, arg1 *access.SubscribeBlocksFromStartBlockIDRequest, arg2 ...grpc.CallOption) (access.AccessAPI_SubscribeBlocksFromStartBlockIDClient, error) { +func (m *MockAccessAPIClient) SubscribeBlocksFromStartBlockID(ctx context.Context, in *access.SubscribeBlocksFromStartBlockIDRequest, opts ...grpc.CallOption) (access.AccessAPI_SubscribeBlocksFromStartBlockIDClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeBlocksFromStartBlockID", varargs...) @@ -975,17 +976,17 @@ func (m *MockAccessAPIClient) SubscribeBlocksFromStartBlockID(arg0 context.Conte } // SubscribeBlocksFromStartBlockID indicates an expected call of SubscribeBlocksFromStartBlockID. -func (mr *MockAccessAPIClientMockRecorder) SubscribeBlocksFromStartBlockID(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) SubscribeBlocksFromStartBlockID(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeBlocksFromStartBlockID", reflect.TypeOf((*MockAccessAPIClient)(nil).SubscribeBlocksFromStartBlockID), varargs...) } // SubscribeBlocksFromStartHeight mocks base method. -func (m *MockAccessAPIClient) SubscribeBlocksFromStartHeight(arg0 context.Context, arg1 *access.SubscribeBlocksFromStartHeightRequest, arg2 ...grpc.CallOption) (access.AccessAPI_SubscribeBlocksFromStartHeightClient, error) { +func (m *MockAccessAPIClient) SubscribeBlocksFromStartHeight(ctx context.Context, in *access.SubscribeBlocksFromStartHeightRequest, opts ...grpc.CallOption) (access.AccessAPI_SubscribeBlocksFromStartHeightClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeBlocksFromStartHeight", varargs...) @@ -995,8 +996,8 @@ func (m *MockAccessAPIClient) SubscribeBlocksFromStartHeight(arg0 context.Contex } // SubscribeBlocksFromStartHeight indicates an expected call of SubscribeBlocksFromStartHeight. -func (mr *MockAccessAPIClientMockRecorder) SubscribeBlocksFromStartHeight(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockAccessAPIClientMockRecorder) SubscribeBlocksFromStartHeight(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeBlocksFromStartHeight", reflect.TypeOf((*MockAccessAPIClient)(nil).SubscribeBlocksFromStartHeight), varargs...) } diff --git a/internal/mocks/executiondata.go b/internal/mocks/executiondata.go index 3a3184d3..ff561e85 100644 --- a/internal/mocks/executiondata.go +++ b/internal/mocks/executiondata.go @@ -22,6 +22,7 @@ import ( type MockExecutionDataAPIClient struct { ctrl *gomock.Controller recorder *MockExecutionDataAPIClientMockRecorder + isgomock struct{} } // MockExecutionDataAPIClientMockRecorder is the mock recorder for MockExecutionDataAPIClient. @@ -42,10 +43,10 @@ func (m *MockExecutionDataAPIClient) EXPECT() *MockExecutionDataAPIClientMockRec } // GetExecutionDataByBlockID mocks base method. -func (m *MockExecutionDataAPIClient) GetExecutionDataByBlockID(arg0 context.Context, arg1 *executiondata.GetExecutionDataByBlockIDRequest, arg2 ...grpc.CallOption) (*executiondata.GetExecutionDataByBlockIDResponse, error) { +func (m *MockExecutionDataAPIClient) GetExecutionDataByBlockID(ctx context.Context, in *executiondata.GetExecutionDataByBlockIDRequest, opts ...grpc.CallOption) (*executiondata.GetExecutionDataByBlockIDResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetExecutionDataByBlockID", varargs...) @@ -55,17 +56,17 @@ func (m *MockExecutionDataAPIClient) GetExecutionDataByBlockID(arg0 context.Cont } // GetExecutionDataByBlockID indicates an expected call of GetExecutionDataByBlockID. -func (mr *MockExecutionDataAPIClientMockRecorder) GetExecutionDataByBlockID(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockExecutionDataAPIClientMockRecorder) GetExecutionDataByBlockID(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExecutionDataByBlockID", reflect.TypeOf((*MockExecutionDataAPIClient)(nil).GetExecutionDataByBlockID), varargs...) } // GetRegisterValues mocks base method. -func (m *MockExecutionDataAPIClient) GetRegisterValues(arg0 context.Context, arg1 *executiondata.GetRegisterValuesRequest, arg2 ...grpc.CallOption) (*executiondata.GetRegisterValuesResponse, error) { +func (m *MockExecutionDataAPIClient) GetRegisterValues(ctx context.Context, in *executiondata.GetRegisterValuesRequest, opts ...grpc.CallOption) (*executiondata.GetRegisterValuesResponse, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetRegisterValues", varargs...) @@ -75,17 +76,17 @@ func (m *MockExecutionDataAPIClient) GetRegisterValues(arg0 context.Context, arg } // GetRegisterValues indicates an expected call of GetRegisterValues. -func (mr *MockExecutionDataAPIClientMockRecorder) GetRegisterValues(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockExecutionDataAPIClientMockRecorder) GetRegisterValues(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRegisterValues", reflect.TypeOf((*MockExecutionDataAPIClient)(nil).GetRegisterValues), varargs...) } // SubscribeAccountStatusesFromLatestBlock mocks base method. -func (m *MockExecutionDataAPIClient) SubscribeAccountStatusesFromLatestBlock(arg0 context.Context, arg1 *executiondata.SubscribeAccountStatusesFromLatestBlockRequest, arg2 ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeAccountStatusesFromLatestBlockClient, error) { +func (m *MockExecutionDataAPIClient) SubscribeAccountStatusesFromLatestBlock(ctx context.Context, in *executiondata.SubscribeAccountStatusesFromLatestBlockRequest, opts ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeAccountStatusesFromLatestBlockClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeAccountStatusesFromLatestBlock", varargs...) @@ -95,17 +96,17 @@ func (m *MockExecutionDataAPIClient) SubscribeAccountStatusesFromLatestBlock(arg } // SubscribeAccountStatusesFromLatestBlock indicates an expected call of SubscribeAccountStatusesFromLatestBlock. -func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeAccountStatusesFromLatestBlock(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeAccountStatusesFromLatestBlock(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeAccountStatusesFromLatestBlock", reflect.TypeOf((*MockExecutionDataAPIClient)(nil).SubscribeAccountStatusesFromLatestBlock), varargs...) } // SubscribeAccountStatusesFromStartBlockID mocks base method. -func (m *MockExecutionDataAPIClient) SubscribeAccountStatusesFromStartBlockID(arg0 context.Context, arg1 *executiondata.SubscribeAccountStatusesFromStartBlockIDRequest, arg2 ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeAccountStatusesFromStartBlockIDClient, error) { +func (m *MockExecutionDataAPIClient) SubscribeAccountStatusesFromStartBlockID(ctx context.Context, in *executiondata.SubscribeAccountStatusesFromStartBlockIDRequest, opts ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeAccountStatusesFromStartBlockIDClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeAccountStatusesFromStartBlockID", varargs...) @@ -115,17 +116,17 @@ func (m *MockExecutionDataAPIClient) SubscribeAccountStatusesFromStartBlockID(ar } // SubscribeAccountStatusesFromStartBlockID indicates an expected call of SubscribeAccountStatusesFromStartBlockID. -func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeAccountStatusesFromStartBlockID(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeAccountStatusesFromStartBlockID(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeAccountStatusesFromStartBlockID", reflect.TypeOf((*MockExecutionDataAPIClient)(nil).SubscribeAccountStatusesFromStartBlockID), varargs...) } // SubscribeAccountStatusesFromStartHeight mocks base method. -func (m *MockExecutionDataAPIClient) SubscribeAccountStatusesFromStartHeight(arg0 context.Context, arg1 *executiondata.SubscribeAccountStatusesFromStartHeightRequest, arg2 ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeAccountStatusesFromStartHeightClient, error) { +func (m *MockExecutionDataAPIClient) SubscribeAccountStatusesFromStartHeight(ctx context.Context, in *executiondata.SubscribeAccountStatusesFromStartHeightRequest, opts ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeAccountStatusesFromStartHeightClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeAccountStatusesFromStartHeight", varargs...) @@ -135,17 +136,17 @@ func (m *MockExecutionDataAPIClient) SubscribeAccountStatusesFromStartHeight(arg } // SubscribeAccountStatusesFromStartHeight indicates an expected call of SubscribeAccountStatusesFromStartHeight. -func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeAccountStatusesFromStartHeight(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeAccountStatusesFromStartHeight(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeAccountStatusesFromStartHeight", reflect.TypeOf((*MockExecutionDataAPIClient)(nil).SubscribeAccountStatusesFromStartHeight), varargs...) } // SubscribeEvents mocks base method. -func (m *MockExecutionDataAPIClient) SubscribeEvents(arg0 context.Context, arg1 *executiondata.SubscribeEventsRequest, arg2 ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeEventsClient, error) { +func (m *MockExecutionDataAPIClient) SubscribeEvents(ctx context.Context, in *executiondata.SubscribeEventsRequest, opts ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeEventsClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeEvents", varargs...) @@ -155,17 +156,17 @@ func (m *MockExecutionDataAPIClient) SubscribeEvents(arg0 context.Context, arg1 } // SubscribeEvents indicates an expected call of SubscribeEvents. -func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeEvents(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeEvents(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeEvents", reflect.TypeOf((*MockExecutionDataAPIClient)(nil).SubscribeEvents), varargs...) } // SubscribeEventsFromLatest mocks base method. -func (m *MockExecutionDataAPIClient) SubscribeEventsFromLatest(arg0 context.Context, arg1 *executiondata.SubscribeEventsFromLatestRequest, arg2 ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeEventsFromLatestClient, error) { +func (m *MockExecutionDataAPIClient) SubscribeEventsFromLatest(ctx context.Context, in *executiondata.SubscribeEventsFromLatestRequest, opts ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeEventsFromLatestClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeEventsFromLatest", varargs...) @@ -175,17 +176,17 @@ func (m *MockExecutionDataAPIClient) SubscribeEventsFromLatest(arg0 context.Cont } // SubscribeEventsFromLatest indicates an expected call of SubscribeEventsFromLatest. -func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeEventsFromLatest(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeEventsFromLatest(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeEventsFromLatest", reflect.TypeOf((*MockExecutionDataAPIClient)(nil).SubscribeEventsFromLatest), varargs...) } // SubscribeEventsFromStartBlockID mocks base method. -func (m *MockExecutionDataAPIClient) SubscribeEventsFromStartBlockID(arg0 context.Context, arg1 *executiondata.SubscribeEventsFromStartBlockIDRequest, arg2 ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeEventsFromStartBlockIDClient, error) { +func (m *MockExecutionDataAPIClient) SubscribeEventsFromStartBlockID(ctx context.Context, in *executiondata.SubscribeEventsFromStartBlockIDRequest, opts ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeEventsFromStartBlockIDClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeEventsFromStartBlockID", varargs...) @@ -195,17 +196,17 @@ func (m *MockExecutionDataAPIClient) SubscribeEventsFromStartBlockID(arg0 contex } // SubscribeEventsFromStartBlockID indicates an expected call of SubscribeEventsFromStartBlockID. -func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeEventsFromStartBlockID(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeEventsFromStartBlockID(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeEventsFromStartBlockID", reflect.TypeOf((*MockExecutionDataAPIClient)(nil).SubscribeEventsFromStartBlockID), varargs...) } // SubscribeEventsFromStartHeight mocks base method. -func (m *MockExecutionDataAPIClient) SubscribeEventsFromStartHeight(arg0 context.Context, arg1 *executiondata.SubscribeEventsFromStartHeightRequest, arg2 ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeEventsFromStartHeightClient, error) { +func (m *MockExecutionDataAPIClient) SubscribeEventsFromStartHeight(ctx context.Context, in *executiondata.SubscribeEventsFromStartHeightRequest, opts ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeEventsFromStartHeightClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeEventsFromStartHeight", varargs...) @@ -215,17 +216,17 @@ func (m *MockExecutionDataAPIClient) SubscribeEventsFromStartHeight(arg0 context } // SubscribeEventsFromStartHeight indicates an expected call of SubscribeEventsFromStartHeight. -func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeEventsFromStartHeight(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeEventsFromStartHeight(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeEventsFromStartHeight", reflect.TypeOf((*MockExecutionDataAPIClient)(nil).SubscribeEventsFromStartHeight), varargs...) } // SubscribeExecutionData mocks base method. -func (m *MockExecutionDataAPIClient) SubscribeExecutionData(arg0 context.Context, arg1 *executiondata.SubscribeExecutionDataRequest, arg2 ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeExecutionDataClient, error) { +func (m *MockExecutionDataAPIClient) SubscribeExecutionData(ctx context.Context, in *executiondata.SubscribeExecutionDataRequest, opts ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeExecutionDataClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeExecutionData", varargs...) @@ -235,17 +236,17 @@ func (m *MockExecutionDataAPIClient) SubscribeExecutionData(arg0 context.Context } // SubscribeExecutionData indicates an expected call of SubscribeExecutionData. -func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeExecutionData(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeExecutionData(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeExecutionData", reflect.TypeOf((*MockExecutionDataAPIClient)(nil).SubscribeExecutionData), varargs...) } // SubscribeExecutionDataFromLatest mocks base method. -func (m *MockExecutionDataAPIClient) SubscribeExecutionDataFromLatest(arg0 context.Context, arg1 *executiondata.SubscribeExecutionDataFromLatestRequest, arg2 ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeExecutionDataFromLatestClient, error) { +func (m *MockExecutionDataAPIClient) SubscribeExecutionDataFromLatest(ctx context.Context, in *executiondata.SubscribeExecutionDataFromLatestRequest, opts ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeExecutionDataFromLatestClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeExecutionDataFromLatest", varargs...) @@ -255,17 +256,17 @@ func (m *MockExecutionDataAPIClient) SubscribeExecutionDataFromLatest(arg0 conte } // SubscribeExecutionDataFromLatest indicates an expected call of SubscribeExecutionDataFromLatest. -func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeExecutionDataFromLatest(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeExecutionDataFromLatest(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeExecutionDataFromLatest", reflect.TypeOf((*MockExecutionDataAPIClient)(nil).SubscribeExecutionDataFromLatest), varargs...) } // SubscribeExecutionDataFromStartBlockHeight mocks base method. -func (m *MockExecutionDataAPIClient) SubscribeExecutionDataFromStartBlockHeight(arg0 context.Context, arg1 *executiondata.SubscribeExecutionDataFromStartBlockHeightRequest, arg2 ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeExecutionDataFromStartBlockHeightClient, error) { +func (m *MockExecutionDataAPIClient) SubscribeExecutionDataFromStartBlockHeight(ctx context.Context, in *executiondata.SubscribeExecutionDataFromStartBlockHeightRequest, opts ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeExecutionDataFromStartBlockHeightClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeExecutionDataFromStartBlockHeight", varargs...) @@ -275,17 +276,17 @@ func (m *MockExecutionDataAPIClient) SubscribeExecutionDataFromStartBlockHeight( } // SubscribeExecutionDataFromStartBlockHeight indicates an expected call of SubscribeExecutionDataFromStartBlockHeight. -func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeExecutionDataFromStartBlockHeight(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeExecutionDataFromStartBlockHeight(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeExecutionDataFromStartBlockHeight", reflect.TypeOf((*MockExecutionDataAPIClient)(nil).SubscribeExecutionDataFromStartBlockHeight), varargs...) } // SubscribeExecutionDataFromStartBlockID mocks base method. -func (m *MockExecutionDataAPIClient) SubscribeExecutionDataFromStartBlockID(arg0 context.Context, arg1 *executiondata.SubscribeExecutionDataFromStartBlockIDRequest, arg2 ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeExecutionDataFromStartBlockIDClient, error) { +func (m *MockExecutionDataAPIClient) SubscribeExecutionDataFromStartBlockID(ctx context.Context, in *executiondata.SubscribeExecutionDataFromStartBlockIDRequest, opts ...grpc.CallOption) (executiondata.ExecutionDataAPI_SubscribeExecutionDataFromStartBlockIDClient, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, in} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SubscribeExecutionDataFromStartBlockID", varargs...) @@ -295,8 +296,8 @@ func (m *MockExecutionDataAPIClient) SubscribeExecutionDataFromStartBlockID(arg0 } // SubscribeExecutionDataFromStartBlockID indicates an expected call of SubscribeExecutionDataFromStartBlockID. -func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeExecutionDataFromStartBlockID(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockExecutionDataAPIClientMockRecorder) SubscribeExecutionDataFromStartBlockID(ctx, in any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, in}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeExecutionDataFromStartBlockID", reflect.TypeOf((*MockExecutionDataAPIClient)(nil).SubscribeExecutionDataFromStartBlockID), varargs...) } diff --git a/storage/mocks/store.go b/storage/mocks/store.go index a3263bc8..c2090ea9 100644 --- a/storage/mocks/store.go +++ b/storage/mocks/store.go @@ -23,6 +23,7 @@ import ( type MockStore struct { ctrl *gomock.Controller recorder *MockStoreMockRecorder + isgomock struct{} } // MockStoreMockRecorder is the mock recorder for MockStore. @@ -43,137 +44,137 @@ func (m *MockStore) EXPECT() *MockStoreMockRecorder { } // BlockByHeight mocks base method. -func (m *MockStore) BlockByHeight(arg0 context.Context, arg1 uint64) (*flow.Block, error) { +func (m *MockStore) BlockByHeight(ctx context.Context, height uint64) (*flow.Block, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BlockByHeight", arg0, arg1) + ret := m.ctrl.Call(m, "BlockByHeight", ctx, height) ret0, _ := ret[0].(*flow.Block) ret1, _ := ret[1].(error) return ret0, ret1 } // BlockByHeight indicates an expected call of BlockByHeight. -func (mr *MockStoreMockRecorder) BlockByHeight(arg0, arg1 any) *gomock.Call { +func (mr *MockStoreMockRecorder) BlockByHeight(ctx, height any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHeight", reflect.TypeOf((*MockStore)(nil).BlockByHeight), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHeight", reflect.TypeOf((*MockStore)(nil).BlockByHeight), ctx, height) } // BlockByID mocks base method. -func (m *MockStore) BlockByID(arg0 context.Context, arg1 flow.Identifier) (*flow.Block, error) { +func (m *MockStore) BlockByID(ctx context.Context, blockID flow.Identifier) (*flow.Block, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BlockByID", arg0, arg1) + ret := m.ctrl.Call(m, "BlockByID", ctx, blockID) ret0, _ := ret[0].(*flow.Block) ret1, _ := ret[1].(error) return ret0, ret1 } // BlockByID indicates an expected call of BlockByID. -func (mr *MockStoreMockRecorder) BlockByID(arg0, arg1 any) *gomock.Call { +func (mr *MockStoreMockRecorder) BlockByID(ctx, blockID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByID", reflect.TypeOf((*MockStore)(nil).BlockByID), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByID", reflect.TypeOf((*MockStore)(nil).BlockByID), ctx, blockID) } // CollectionByID mocks base method. -func (m *MockStore) CollectionByID(arg0 context.Context, arg1 flow.Identifier) (flow.LightCollection, error) { +func (m *MockStore) CollectionByID(ctx context.Context, collectionID flow.Identifier) (flow.LightCollection, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CollectionByID", arg0, arg1) + ret := m.ctrl.Call(m, "CollectionByID", ctx, collectionID) ret0, _ := ret[0].(flow.LightCollection) ret1, _ := ret[1].(error) return ret0, ret1 } // CollectionByID indicates an expected call of CollectionByID. -func (mr *MockStoreMockRecorder) CollectionByID(arg0, arg1 any) *gomock.Call { +func (mr *MockStoreMockRecorder) CollectionByID(ctx, collectionID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectionByID", reflect.TypeOf((*MockStore)(nil).CollectionByID), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectionByID", reflect.TypeOf((*MockStore)(nil).CollectionByID), ctx, collectionID) } // CommitBlock mocks base method. -func (m *MockStore) CommitBlock(arg0 context.Context, arg1 flow.Block, arg2 []*flow.LightCollection, arg3 map[flow.Identifier]*flow.TransactionBody, arg4 map[flow.Identifier]*types.StorableTransactionResult, arg5 *snapshot.ExecutionSnapshot, arg6 []flow.Event) error { +func (m *MockStore) CommitBlock(ctx context.Context, block flow.Block, collections []*flow.LightCollection, transactions map[flow.Identifier]*flow.TransactionBody, transactionResults map[flow.Identifier]*types.StorableTransactionResult, executionSnapshot *snapshot.ExecutionSnapshot, events []flow.Event) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CommitBlock", arg0, arg1, arg2, arg3, arg4, arg5, arg6) + ret := m.ctrl.Call(m, "CommitBlock", ctx, block, collections, transactions, transactionResults, executionSnapshot, events) ret0, _ := ret[0].(error) return ret0 } // CommitBlock indicates an expected call of CommitBlock. -func (mr *MockStoreMockRecorder) CommitBlock(arg0, arg1, arg2, arg3, arg4, arg5, arg6 any) *gomock.Call { +func (mr *MockStoreMockRecorder) CommitBlock(ctx, block, collections, transactions, transactionResults, executionSnapshot, events any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitBlock", reflect.TypeOf((*MockStore)(nil).CommitBlock), arg0, arg1, arg2, arg3, arg4, arg5, arg6) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitBlock", reflect.TypeOf((*MockStore)(nil).CommitBlock), ctx, block, collections, transactions, transactionResults, executionSnapshot, events) } // EventsByHeight mocks base method. -func (m *MockStore) EventsByHeight(arg0 context.Context, arg1 uint64, arg2 string) ([]flow.Event, error) { +func (m *MockStore) EventsByHeight(ctx context.Context, blockHeight uint64, eventType string) ([]flow.Event, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EventsByHeight", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "EventsByHeight", ctx, blockHeight, eventType) ret0, _ := ret[0].([]flow.Event) ret1, _ := ret[1].(error) return ret0, ret1 } // EventsByHeight indicates an expected call of EventsByHeight. -func (mr *MockStoreMockRecorder) EventsByHeight(arg0, arg1, arg2 any) *gomock.Call { +func (mr *MockStoreMockRecorder) EventsByHeight(ctx, blockHeight, eventType any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventsByHeight", reflect.TypeOf((*MockStore)(nil).EventsByHeight), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventsByHeight", reflect.TypeOf((*MockStore)(nil).EventsByHeight), ctx, blockHeight, eventType) } // FullCollectionByID mocks base method. -func (m *MockStore) FullCollectionByID(arg0 context.Context, arg1 flow.Identifier) (flow.Collection, error) { +func (m *MockStore) FullCollectionByID(ctx context.Context, collectionID flow.Identifier) (flow.Collection, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FullCollectionByID", arg0, arg1) + ret := m.ctrl.Call(m, "FullCollectionByID", ctx, collectionID) ret0, _ := ret[0].(flow.Collection) ret1, _ := ret[1].(error) return ret0, ret1 } // FullCollectionByID indicates an expected call of FullCollectionByID. -func (mr *MockStoreMockRecorder) FullCollectionByID(arg0, arg1 any) *gomock.Call { +func (mr *MockStoreMockRecorder) FullCollectionByID(ctx, collectionID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FullCollectionByID", reflect.TypeOf((*MockStore)(nil).FullCollectionByID), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FullCollectionByID", reflect.TypeOf((*MockStore)(nil).FullCollectionByID), ctx, collectionID) } // LatestBlock mocks base method. -func (m *MockStore) LatestBlock(arg0 context.Context) (flow.Block, error) { +func (m *MockStore) LatestBlock(ctx context.Context) (flow.Block, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LatestBlock", arg0) + ret := m.ctrl.Call(m, "LatestBlock", ctx) ret0, _ := ret[0].(flow.Block) ret1, _ := ret[1].(error) return ret0, ret1 } // LatestBlock indicates an expected call of LatestBlock. -func (mr *MockStoreMockRecorder) LatestBlock(arg0 any) *gomock.Call { +func (mr *MockStoreMockRecorder) LatestBlock(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestBlock", reflect.TypeOf((*MockStore)(nil).LatestBlock), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestBlock", reflect.TypeOf((*MockStore)(nil).LatestBlock), ctx) } // LatestBlockHeight mocks base method. -func (m *MockStore) LatestBlockHeight(arg0 context.Context) (uint64, error) { +func (m *MockStore) LatestBlockHeight(ctx context.Context) (uint64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LatestBlockHeight", arg0) + ret := m.ctrl.Call(m, "LatestBlockHeight", ctx) ret0, _ := ret[0].(uint64) ret1, _ := ret[1].(error) return ret0, ret1 } // LatestBlockHeight indicates an expected call of LatestBlockHeight. -func (mr *MockStoreMockRecorder) LatestBlockHeight(arg0 any) *gomock.Call { +func (mr *MockStoreMockRecorder) LatestBlockHeight(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestBlockHeight", reflect.TypeOf((*MockStore)(nil).LatestBlockHeight), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestBlockHeight", reflect.TypeOf((*MockStore)(nil).LatestBlockHeight), ctx) } // LedgerByHeight mocks base method. -func (m *MockStore) LedgerByHeight(arg0 context.Context, arg1 uint64) (snapshot.StorageSnapshot, error) { +func (m *MockStore) LedgerByHeight(ctx context.Context, blockHeight uint64) (snapshot.StorageSnapshot, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LedgerByHeight", arg0, arg1) + ret := m.ctrl.Call(m, "LedgerByHeight", ctx, blockHeight) ret0, _ := ret[0].(snapshot.StorageSnapshot) ret1, _ := ret[1].(error) return ret0, ret1 } // LedgerByHeight indicates an expected call of LedgerByHeight. -func (mr *MockStoreMockRecorder) LedgerByHeight(arg0, arg1 any) *gomock.Call { +func (mr *MockStoreMockRecorder) LedgerByHeight(ctx, blockHeight any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LedgerByHeight", reflect.TypeOf((*MockStore)(nil).LedgerByHeight), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LedgerByHeight", reflect.TypeOf((*MockStore)(nil).LedgerByHeight), ctx, blockHeight) } // Start mocks base method. @@ -203,45 +204,45 @@ func (mr *MockStoreMockRecorder) Stop() *gomock.Call { } // StoreBlock mocks base method. -func (m *MockStore) StoreBlock(arg0 context.Context, arg1 *flow.Block) error { +func (m *MockStore) StoreBlock(ctx context.Context, block *flow.Block) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StoreBlock", arg0, arg1) + ret := m.ctrl.Call(m, "StoreBlock", ctx, block) ret0, _ := ret[0].(error) return ret0 } // StoreBlock indicates an expected call of StoreBlock. -func (mr *MockStoreMockRecorder) StoreBlock(arg0, arg1 any) *gomock.Call { +func (mr *MockStoreMockRecorder) StoreBlock(ctx, block any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreBlock", reflect.TypeOf((*MockStore)(nil).StoreBlock), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreBlock", reflect.TypeOf((*MockStore)(nil).StoreBlock), ctx, block) } // TransactionByID mocks base method. -func (m *MockStore) TransactionByID(arg0 context.Context, arg1 flow.Identifier) (flow.TransactionBody, error) { +func (m *MockStore) TransactionByID(ctx context.Context, transactionID flow.Identifier) (flow.TransactionBody, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TransactionByID", arg0, arg1) + ret := m.ctrl.Call(m, "TransactionByID", ctx, transactionID) ret0, _ := ret[0].(flow.TransactionBody) ret1, _ := ret[1].(error) return ret0, ret1 } // TransactionByID indicates an expected call of TransactionByID. -func (mr *MockStoreMockRecorder) TransactionByID(arg0, arg1 any) *gomock.Call { +func (mr *MockStoreMockRecorder) TransactionByID(ctx, transactionID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByID", reflect.TypeOf((*MockStore)(nil).TransactionByID), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByID", reflect.TypeOf((*MockStore)(nil).TransactionByID), ctx, transactionID) } // TransactionResultByID mocks base method. -func (m *MockStore) TransactionResultByID(arg0 context.Context, arg1 flow.Identifier) (types.StorableTransactionResult, error) { +func (m *MockStore) TransactionResultByID(ctx context.Context, transactionID flow.Identifier) (types.StorableTransactionResult, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TransactionResultByID", arg0, arg1) + ret := m.ctrl.Call(m, "TransactionResultByID", ctx, transactionID) ret0, _ := ret[0].(types.StorableTransactionResult) ret1, _ := ret[1].(error) return ret0, ret1 } // TransactionResultByID indicates an expected call of TransactionResultByID. -func (mr *MockStoreMockRecorder) TransactionResultByID(arg0, arg1 any) *gomock.Call { +func (mr *MockStoreMockRecorder) TransactionResultByID(ctx, transactionID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionResultByID", reflect.TypeOf((*MockStore)(nil).TransactionResultByID), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionResultByID", reflect.TypeOf((*MockStore)(nil).TransactionResultByID), ctx, transactionID) }