diff --git a/.changeset/mean-views-punch.md b/.changeset/mean-views-punch.md new file mode 100644 index 000000000..66a9a73c9 --- /dev/null +++ b/.changeset/mean-views-punch.md @@ -0,0 +1,5 @@ +--- +"chainlink-deployments-framework": patch +--- + +feat: add signer methods to mcms adapters diff --git a/.mockery.yml b/.mockery.yml index a61e743db..8a896cbcc 100644 --- a/.mockery.yml +++ b/.mockery.yml @@ -123,3 +123,28 @@ packages: BatchOperationAnalyzer: CallAnalyzer: ParameterAnalyzer: + github.com/aptos-labs/aptos-go-sdk: + config: + all: false + pkgname: "mocks" + dir: "chain/aptos/mocks" + filename: "{{.InterfaceName | snakecase}}.go" + interfaces: + AptosRpcClient: + TransactionSigner: + github.com/block-vision/sui-go-sdk/sui: + config: + all: false + pkgname: "mocks" + dir: "chain/sui/mocks" + filename: "{{.InterfaceName | snakecase}}.go" + interfaces: + ISuiAPI: + github.com/xssnick/tonutils-go/ton: + config: + all: false + pkgname: "mocks" + dir: "chain/ton/mocks" + filename: "{{.InterfaceName | snakecase}}.go" + interfaces: + APIClientWrapped: diff --git a/chain/aptos/mocks/aptos_rpc_client.go b/chain/aptos/mocks/aptos_rpc_client.go new file mode 100644 index 000000000..552519cb6 --- /dev/null +++ b/chain/aptos/mocks/aptos_rpc_client.go @@ -0,0 +1,2431 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify + +package mocks + +import ( + "time" + + "github.com/aptos-labs/aptos-go-sdk" + "github.com/aptos-labs/aptos-go-sdk/api" + mock "github.com/stretchr/testify/mock" +) + +// NewMockAptosRpcClient creates a new instance of MockAptosRpcClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockAptosRpcClient(t interface { + mock.TestingT + Cleanup(func()) +}) *MockAptosRpcClient { + mock := &MockAptosRpcClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + +// MockAptosRpcClient is an autogenerated mock type for the AptosRpcClient type +type MockAptosRpcClient struct { + mock.Mock +} + +type MockAptosRpcClient_Expecter struct { + mock *mock.Mock +} + +func (_m *MockAptosRpcClient) EXPECT() *MockAptosRpcClient_Expecter { + return &MockAptosRpcClient_Expecter{mock: &_m.Mock} +} + +// Account provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) Account(address aptos.AccountAddress, ledgerVersion ...uint64) (aptos.AccountInfo, error) { + var tmpRet mock.Arguments + if len(ledgerVersion) > 0 { + tmpRet = _mock.Called(address, ledgerVersion) + } else { + tmpRet = _mock.Called(address) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for Account") + } + + var r0 aptos.AccountInfo + var r1 error + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, ...uint64) (aptos.AccountInfo, error)); ok { + return returnFunc(address, ledgerVersion...) + } + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, ...uint64) aptos.AccountInfo); ok { + r0 = returnFunc(address, ledgerVersion...) + } else { + r0 = ret.Get(0).(aptos.AccountInfo) + } + if returnFunc, ok := ret.Get(1).(func(aptos.AccountAddress, ...uint64) error); ok { + r1 = returnFunc(address, ledgerVersion...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_Account_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Account' +type MockAptosRpcClient_Account_Call struct { + *mock.Call +} + +// Account is a helper method to define mock.On call +// - address aptos.AccountAddress +// - ledgerVersion ...uint64 +func (_e *MockAptosRpcClient_Expecter) Account(address interface{}, ledgerVersion ...interface{}) *MockAptosRpcClient_Account_Call { + return &MockAptosRpcClient_Account_Call{Call: _e.mock.On("Account", + append([]interface{}{address}, ledgerVersion...)...)} +} + +func (_c *MockAptosRpcClient_Account_Call) Run(run func(address aptos.AccountAddress, ledgerVersion ...uint64)) *MockAptosRpcClient_Account_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aptos.AccountAddress + if args[0] != nil { + arg0 = args[0].(aptos.AccountAddress) + } + var arg1 []uint64 + var variadicArgs []uint64 + if len(args) > 1 { + variadicArgs = args[1].([]uint64) + } + arg1 = variadicArgs + run( + arg0, + arg1..., + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_Account_Call) Return(accountInfo aptos.AccountInfo, err error) *MockAptosRpcClient_Account_Call { + _c.Call.Return(accountInfo, err) + return _c +} + +func (_c *MockAptosRpcClient_Account_Call) RunAndReturn(run func(address aptos.AccountAddress, ledgerVersion ...uint64) (aptos.AccountInfo, error)) *MockAptosRpcClient_Account_Call { + _c.Call.Return(run) + return _c +} + +// AccountAPTBalance provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) AccountAPTBalance(address aptos.AccountAddress, ledgerVersion ...uint64) (uint64, error) { + var tmpRet mock.Arguments + if len(ledgerVersion) > 0 { + tmpRet = _mock.Called(address, ledgerVersion) + } else { + tmpRet = _mock.Called(address) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for AccountAPTBalance") + } + + var r0 uint64 + var r1 error + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, ...uint64) (uint64, error)); ok { + return returnFunc(address, ledgerVersion...) + } + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, ...uint64) uint64); ok { + r0 = returnFunc(address, ledgerVersion...) + } else { + r0 = ret.Get(0).(uint64) + } + if returnFunc, ok := ret.Get(1).(func(aptos.AccountAddress, ...uint64) error); ok { + r1 = returnFunc(address, ledgerVersion...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_AccountAPTBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AccountAPTBalance' +type MockAptosRpcClient_AccountAPTBalance_Call struct { + *mock.Call +} + +// AccountAPTBalance is a helper method to define mock.On call +// - address aptos.AccountAddress +// - ledgerVersion ...uint64 +func (_e *MockAptosRpcClient_Expecter) AccountAPTBalance(address interface{}, ledgerVersion ...interface{}) *MockAptosRpcClient_AccountAPTBalance_Call { + return &MockAptosRpcClient_AccountAPTBalance_Call{Call: _e.mock.On("AccountAPTBalance", + append([]interface{}{address}, ledgerVersion...)...)} +} + +func (_c *MockAptosRpcClient_AccountAPTBalance_Call) Run(run func(address aptos.AccountAddress, ledgerVersion ...uint64)) *MockAptosRpcClient_AccountAPTBalance_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aptos.AccountAddress + if args[0] != nil { + arg0 = args[0].(aptos.AccountAddress) + } + var arg1 []uint64 + var variadicArgs []uint64 + if len(args) > 1 { + variadicArgs = args[1].([]uint64) + } + arg1 = variadicArgs + run( + arg0, + arg1..., + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_AccountAPTBalance_Call) Return(v uint64, err error) *MockAptosRpcClient_AccountAPTBalance_Call { + _c.Call.Return(v, err) + return _c +} + +func (_c *MockAptosRpcClient_AccountAPTBalance_Call) RunAndReturn(run func(address aptos.AccountAddress, ledgerVersion ...uint64) (uint64, error)) *MockAptosRpcClient_AccountAPTBalance_Call { + _c.Call.Return(run) + return _c +} + +// AccountModule provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) AccountModule(address aptos.AccountAddress, moduleName string, ledgerVersion ...uint64) (*api.MoveBytecode, error) { + var tmpRet mock.Arguments + if len(ledgerVersion) > 0 { + tmpRet = _mock.Called(address, moduleName, ledgerVersion) + } else { + tmpRet = _mock.Called(address, moduleName) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for AccountModule") + } + + var r0 *api.MoveBytecode + var r1 error + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, string, ...uint64) (*api.MoveBytecode, error)); ok { + return returnFunc(address, moduleName, ledgerVersion...) + } + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, string, ...uint64) *api.MoveBytecode); ok { + r0 = returnFunc(address, moduleName, ledgerVersion...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*api.MoveBytecode) + } + } + if returnFunc, ok := ret.Get(1).(func(aptos.AccountAddress, string, ...uint64) error); ok { + r1 = returnFunc(address, moduleName, ledgerVersion...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_AccountModule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AccountModule' +type MockAptosRpcClient_AccountModule_Call struct { + *mock.Call +} + +// AccountModule is a helper method to define mock.On call +// - address aptos.AccountAddress +// - moduleName string +// - ledgerVersion ...uint64 +func (_e *MockAptosRpcClient_Expecter) AccountModule(address interface{}, moduleName interface{}, ledgerVersion ...interface{}) *MockAptosRpcClient_AccountModule_Call { + return &MockAptosRpcClient_AccountModule_Call{Call: _e.mock.On("AccountModule", + append([]interface{}{address, moduleName}, ledgerVersion...)...)} +} + +func (_c *MockAptosRpcClient_AccountModule_Call) Run(run func(address aptos.AccountAddress, moduleName string, ledgerVersion ...uint64)) *MockAptosRpcClient_AccountModule_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aptos.AccountAddress + if args[0] != nil { + arg0 = args[0].(aptos.AccountAddress) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 []uint64 + var variadicArgs []uint64 + if len(args) > 2 { + variadicArgs = args[2].([]uint64) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_AccountModule_Call) Return(moveBytecode *api.MoveBytecode, err error) *MockAptosRpcClient_AccountModule_Call { + _c.Call.Return(moveBytecode, err) + return _c +} + +func (_c *MockAptosRpcClient_AccountModule_Call) RunAndReturn(run func(address aptos.AccountAddress, moduleName string, ledgerVersion ...uint64) (*api.MoveBytecode, error)) *MockAptosRpcClient_AccountModule_Call { + _c.Call.Return(run) + return _c +} + +// AccountResource provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) AccountResource(address aptos.AccountAddress, resourceType string, ledgerVersion ...uint64) (map[string]any, error) { + var tmpRet mock.Arguments + if len(ledgerVersion) > 0 { + tmpRet = _mock.Called(address, resourceType, ledgerVersion) + } else { + tmpRet = _mock.Called(address, resourceType) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for AccountResource") + } + + var r0 map[string]any + var r1 error + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, string, ...uint64) (map[string]any, error)); ok { + return returnFunc(address, resourceType, ledgerVersion...) + } + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, string, ...uint64) map[string]any); ok { + r0 = returnFunc(address, resourceType, ledgerVersion...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[string]any) + } + } + if returnFunc, ok := ret.Get(1).(func(aptos.AccountAddress, string, ...uint64) error); ok { + r1 = returnFunc(address, resourceType, ledgerVersion...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_AccountResource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AccountResource' +type MockAptosRpcClient_AccountResource_Call struct { + *mock.Call +} + +// AccountResource is a helper method to define mock.On call +// - address aptos.AccountAddress +// - resourceType string +// - ledgerVersion ...uint64 +func (_e *MockAptosRpcClient_Expecter) AccountResource(address interface{}, resourceType interface{}, ledgerVersion ...interface{}) *MockAptosRpcClient_AccountResource_Call { + return &MockAptosRpcClient_AccountResource_Call{Call: _e.mock.On("AccountResource", + append([]interface{}{address, resourceType}, ledgerVersion...)...)} +} + +func (_c *MockAptosRpcClient_AccountResource_Call) Run(run func(address aptos.AccountAddress, resourceType string, ledgerVersion ...uint64)) *MockAptosRpcClient_AccountResource_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aptos.AccountAddress + if args[0] != nil { + arg0 = args[0].(aptos.AccountAddress) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 []uint64 + var variadicArgs []uint64 + if len(args) > 2 { + variadicArgs = args[2].([]uint64) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_AccountResource_Call) Return(stringToV map[string]any, err error) *MockAptosRpcClient_AccountResource_Call { + _c.Call.Return(stringToV, err) + return _c +} + +func (_c *MockAptosRpcClient_AccountResource_Call) RunAndReturn(run func(address aptos.AccountAddress, resourceType string, ledgerVersion ...uint64) (map[string]any, error)) *MockAptosRpcClient_AccountResource_Call { + _c.Call.Return(run) + return _c +} + +// AccountResources provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) AccountResources(address aptos.AccountAddress, ledgerVersion ...uint64) ([]aptos.AccountResourceInfo, error) { + var tmpRet mock.Arguments + if len(ledgerVersion) > 0 { + tmpRet = _mock.Called(address, ledgerVersion) + } else { + tmpRet = _mock.Called(address) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for AccountResources") + } + + var r0 []aptos.AccountResourceInfo + var r1 error + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, ...uint64) ([]aptos.AccountResourceInfo, error)); ok { + return returnFunc(address, ledgerVersion...) + } + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, ...uint64) []aptos.AccountResourceInfo); ok { + r0 = returnFunc(address, ledgerVersion...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]aptos.AccountResourceInfo) + } + } + if returnFunc, ok := ret.Get(1).(func(aptos.AccountAddress, ...uint64) error); ok { + r1 = returnFunc(address, ledgerVersion...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_AccountResources_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AccountResources' +type MockAptosRpcClient_AccountResources_Call struct { + *mock.Call +} + +// AccountResources is a helper method to define mock.On call +// - address aptos.AccountAddress +// - ledgerVersion ...uint64 +func (_e *MockAptosRpcClient_Expecter) AccountResources(address interface{}, ledgerVersion ...interface{}) *MockAptosRpcClient_AccountResources_Call { + return &MockAptosRpcClient_AccountResources_Call{Call: _e.mock.On("AccountResources", + append([]interface{}{address}, ledgerVersion...)...)} +} + +func (_c *MockAptosRpcClient_AccountResources_Call) Run(run func(address aptos.AccountAddress, ledgerVersion ...uint64)) *MockAptosRpcClient_AccountResources_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aptos.AccountAddress + if args[0] != nil { + arg0 = args[0].(aptos.AccountAddress) + } + var arg1 []uint64 + var variadicArgs []uint64 + if len(args) > 1 { + variadicArgs = args[1].([]uint64) + } + arg1 = variadicArgs + run( + arg0, + arg1..., + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_AccountResources_Call) Return(accountResourceInfos []aptos.AccountResourceInfo, err error) *MockAptosRpcClient_AccountResources_Call { + _c.Call.Return(accountResourceInfos, err) + return _c +} + +func (_c *MockAptosRpcClient_AccountResources_Call) RunAndReturn(run func(address aptos.AccountAddress, ledgerVersion ...uint64) ([]aptos.AccountResourceInfo, error)) *MockAptosRpcClient_AccountResources_Call { + _c.Call.Return(run) + return _c +} + +// AccountResourcesBCS provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) AccountResourcesBCS(address aptos.AccountAddress, ledgerVersion ...uint64) ([]aptos.AccountResourceRecord, error) { + var tmpRet mock.Arguments + if len(ledgerVersion) > 0 { + tmpRet = _mock.Called(address, ledgerVersion) + } else { + tmpRet = _mock.Called(address) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for AccountResourcesBCS") + } + + var r0 []aptos.AccountResourceRecord + var r1 error + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, ...uint64) ([]aptos.AccountResourceRecord, error)); ok { + return returnFunc(address, ledgerVersion...) + } + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, ...uint64) []aptos.AccountResourceRecord); ok { + r0 = returnFunc(address, ledgerVersion...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]aptos.AccountResourceRecord) + } + } + if returnFunc, ok := ret.Get(1).(func(aptos.AccountAddress, ...uint64) error); ok { + r1 = returnFunc(address, ledgerVersion...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_AccountResourcesBCS_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AccountResourcesBCS' +type MockAptosRpcClient_AccountResourcesBCS_Call struct { + *mock.Call +} + +// AccountResourcesBCS is a helper method to define mock.On call +// - address aptos.AccountAddress +// - ledgerVersion ...uint64 +func (_e *MockAptosRpcClient_Expecter) AccountResourcesBCS(address interface{}, ledgerVersion ...interface{}) *MockAptosRpcClient_AccountResourcesBCS_Call { + return &MockAptosRpcClient_AccountResourcesBCS_Call{Call: _e.mock.On("AccountResourcesBCS", + append([]interface{}{address}, ledgerVersion...)...)} +} + +func (_c *MockAptosRpcClient_AccountResourcesBCS_Call) Run(run func(address aptos.AccountAddress, ledgerVersion ...uint64)) *MockAptosRpcClient_AccountResourcesBCS_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aptos.AccountAddress + if args[0] != nil { + arg0 = args[0].(aptos.AccountAddress) + } + var arg1 []uint64 + var variadicArgs []uint64 + if len(args) > 1 { + variadicArgs = args[1].([]uint64) + } + arg1 = variadicArgs + run( + arg0, + arg1..., + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_AccountResourcesBCS_Call) Return(accountResourceRecords []aptos.AccountResourceRecord, err error) *MockAptosRpcClient_AccountResourcesBCS_Call { + _c.Call.Return(accountResourceRecords, err) + return _c +} + +func (_c *MockAptosRpcClient_AccountResourcesBCS_Call) RunAndReturn(run func(address aptos.AccountAddress, ledgerVersion ...uint64) ([]aptos.AccountResourceRecord, error)) *MockAptosRpcClient_AccountResourcesBCS_Call { + _c.Call.Return(run) + return _c +} + +// AccountTransactions provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) AccountTransactions(address aptos.AccountAddress, start *uint64, limit *uint64) ([]*api.CommittedTransaction, error) { + ret := _mock.Called(address, start, limit) + + if len(ret) == 0 { + panic("no return value specified for AccountTransactions") + } + + var r0 []*api.CommittedTransaction + var r1 error + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, *uint64, *uint64) ([]*api.CommittedTransaction, error)); ok { + return returnFunc(address, start, limit) + } + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, *uint64, *uint64) []*api.CommittedTransaction); ok { + r0 = returnFunc(address, start, limit) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*api.CommittedTransaction) + } + } + if returnFunc, ok := ret.Get(1).(func(aptos.AccountAddress, *uint64, *uint64) error); ok { + r1 = returnFunc(address, start, limit) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_AccountTransactions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AccountTransactions' +type MockAptosRpcClient_AccountTransactions_Call struct { + *mock.Call +} + +// AccountTransactions is a helper method to define mock.On call +// - address aptos.AccountAddress +// - start *uint64 +// - limit *uint64 +func (_e *MockAptosRpcClient_Expecter) AccountTransactions(address interface{}, start interface{}, limit interface{}) *MockAptosRpcClient_AccountTransactions_Call { + return &MockAptosRpcClient_AccountTransactions_Call{Call: _e.mock.On("AccountTransactions", address, start, limit)} +} + +func (_c *MockAptosRpcClient_AccountTransactions_Call) Run(run func(address aptos.AccountAddress, start *uint64, limit *uint64)) *MockAptosRpcClient_AccountTransactions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aptos.AccountAddress + if args[0] != nil { + arg0 = args[0].(aptos.AccountAddress) + } + var arg1 *uint64 + if args[1] != nil { + arg1 = args[1].(*uint64) + } + var arg2 *uint64 + if args[2] != nil { + arg2 = args[2].(*uint64) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_AccountTransactions_Call) Return(committedTransactions []*api.CommittedTransaction, err error) *MockAptosRpcClient_AccountTransactions_Call { + _c.Call.Return(committedTransactions, err) + return _c +} + +func (_c *MockAptosRpcClient_AccountTransactions_Call) RunAndReturn(run func(address aptos.AccountAddress, start *uint64, limit *uint64) ([]*api.CommittedTransaction, error)) *MockAptosRpcClient_AccountTransactions_Call { + _c.Call.Return(run) + return _c +} + +// BatchSubmitTransaction provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) BatchSubmitTransaction(signedTxns []*aptos.SignedTransaction) (*api.BatchSubmitTransactionResponse, error) { + ret := _mock.Called(signedTxns) + + if len(ret) == 0 { + panic("no return value specified for BatchSubmitTransaction") + } + + var r0 *api.BatchSubmitTransactionResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func([]*aptos.SignedTransaction) (*api.BatchSubmitTransactionResponse, error)); ok { + return returnFunc(signedTxns) + } + if returnFunc, ok := ret.Get(0).(func([]*aptos.SignedTransaction) *api.BatchSubmitTransactionResponse); ok { + r0 = returnFunc(signedTxns) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*api.BatchSubmitTransactionResponse) + } + } + if returnFunc, ok := ret.Get(1).(func([]*aptos.SignedTransaction) error); ok { + r1 = returnFunc(signedTxns) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_BatchSubmitTransaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchSubmitTransaction' +type MockAptosRpcClient_BatchSubmitTransaction_Call struct { + *mock.Call +} + +// BatchSubmitTransaction is a helper method to define mock.On call +// - signedTxns []*aptos.SignedTransaction +func (_e *MockAptosRpcClient_Expecter) BatchSubmitTransaction(signedTxns interface{}) *MockAptosRpcClient_BatchSubmitTransaction_Call { + return &MockAptosRpcClient_BatchSubmitTransaction_Call{Call: _e.mock.On("BatchSubmitTransaction", signedTxns)} +} + +func (_c *MockAptosRpcClient_BatchSubmitTransaction_Call) Run(run func(signedTxns []*aptos.SignedTransaction)) *MockAptosRpcClient_BatchSubmitTransaction_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 []*aptos.SignedTransaction + if args[0] != nil { + arg0 = args[0].([]*aptos.SignedTransaction) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_BatchSubmitTransaction_Call) Return(batchSubmitTransactionResponse *api.BatchSubmitTransactionResponse, err error) *MockAptosRpcClient_BatchSubmitTransaction_Call { + _c.Call.Return(batchSubmitTransactionResponse, err) + return _c +} + +func (_c *MockAptosRpcClient_BatchSubmitTransaction_Call) RunAndReturn(run func(signedTxns []*aptos.SignedTransaction) (*api.BatchSubmitTransactionResponse, error)) *MockAptosRpcClient_BatchSubmitTransaction_Call { + _c.Call.Return(run) + return _c +} + +// BlockByHeight provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) BlockByHeight(blockHeight uint64, withTransactions bool) (*api.Block, error) { + ret := _mock.Called(blockHeight, withTransactions) + + if len(ret) == 0 { + panic("no return value specified for BlockByHeight") + } + + var r0 *api.Block + var r1 error + if returnFunc, ok := ret.Get(0).(func(uint64, bool) (*api.Block, error)); ok { + return returnFunc(blockHeight, withTransactions) + } + if returnFunc, ok := ret.Get(0).(func(uint64, bool) *api.Block); ok { + r0 = returnFunc(blockHeight, withTransactions) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*api.Block) + } + } + if returnFunc, ok := ret.Get(1).(func(uint64, bool) error); ok { + r1 = returnFunc(blockHeight, withTransactions) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_BlockByHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockByHeight' +type MockAptosRpcClient_BlockByHeight_Call struct { + *mock.Call +} + +// BlockByHeight is a helper method to define mock.On call +// - blockHeight uint64 +// - withTransactions bool +func (_e *MockAptosRpcClient_Expecter) BlockByHeight(blockHeight interface{}, withTransactions interface{}) *MockAptosRpcClient_BlockByHeight_Call { + return &MockAptosRpcClient_BlockByHeight_Call{Call: _e.mock.On("BlockByHeight", blockHeight, withTransactions)} +} + +func (_c *MockAptosRpcClient_BlockByHeight_Call) Run(run func(blockHeight uint64, withTransactions bool)) *MockAptosRpcClient_BlockByHeight_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 uint64 + if args[0] != nil { + arg0 = args[0].(uint64) + } + var arg1 bool + if args[1] != nil { + arg1 = args[1].(bool) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_BlockByHeight_Call) Return(block *api.Block, err error) *MockAptosRpcClient_BlockByHeight_Call { + _c.Call.Return(block, err) + return _c +} + +func (_c *MockAptosRpcClient_BlockByHeight_Call) RunAndReturn(run func(blockHeight uint64, withTransactions bool) (*api.Block, error)) *MockAptosRpcClient_BlockByHeight_Call { + _c.Call.Return(run) + return _c +} + +// BlockByVersion provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) BlockByVersion(ledgerVersion uint64, withTransactions bool) (*api.Block, error) { + ret := _mock.Called(ledgerVersion, withTransactions) + + if len(ret) == 0 { + panic("no return value specified for BlockByVersion") + } + + var r0 *api.Block + var r1 error + if returnFunc, ok := ret.Get(0).(func(uint64, bool) (*api.Block, error)); ok { + return returnFunc(ledgerVersion, withTransactions) + } + if returnFunc, ok := ret.Get(0).(func(uint64, bool) *api.Block); ok { + r0 = returnFunc(ledgerVersion, withTransactions) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*api.Block) + } + } + if returnFunc, ok := ret.Get(1).(func(uint64, bool) error); ok { + r1 = returnFunc(ledgerVersion, withTransactions) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_BlockByVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockByVersion' +type MockAptosRpcClient_BlockByVersion_Call struct { + *mock.Call +} + +// BlockByVersion is a helper method to define mock.On call +// - ledgerVersion uint64 +// - withTransactions bool +func (_e *MockAptosRpcClient_Expecter) BlockByVersion(ledgerVersion interface{}, withTransactions interface{}) *MockAptosRpcClient_BlockByVersion_Call { + return &MockAptosRpcClient_BlockByVersion_Call{Call: _e.mock.On("BlockByVersion", ledgerVersion, withTransactions)} +} + +func (_c *MockAptosRpcClient_BlockByVersion_Call) Run(run func(ledgerVersion uint64, withTransactions bool)) *MockAptosRpcClient_BlockByVersion_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 uint64 + if args[0] != nil { + arg0 = args[0].(uint64) + } + var arg1 bool + if args[1] != nil { + arg1 = args[1].(bool) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_BlockByVersion_Call) Return(block *api.Block, err error) *MockAptosRpcClient_BlockByVersion_Call { + _c.Call.Return(block, err) + return _c +} + +func (_c *MockAptosRpcClient_BlockByVersion_Call) RunAndReturn(run func(ledgerVersion uint64, withTransactions bool) (*api.Block, error)) *MockAptosRpcClient_BlockByVersion_Call { + _c.Call.Return(run) + return _c +} + +// BuildSignAndSubmitTransaction provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) BuildSignAndSubmitTransaction(sender aptos.TransactionSigner, payload aptos.TransactionPayload, options ...any) (*api.SubmitTransactionResponse, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(sender, payload, options) + } else { + tmpRet = _mock.Called(sender, payload) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for BuildSignAndSubmitTransaction") + } + + var r0 *api.SubmitTransactionResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(aptos.TransactionSigner, aptos.TransactionPayload, ...any) (*api.SubmitTransactionResponse, error)); ok { + return returnFunc(sender, payload, options...) + } + if returnFunc, ok := ret.Get(0).(func(aptos.TransactionSigner, aptos.TransactionPayload, ...any) *api.SubmitTransactionResponse); ok { + r0 = returnFunc(sender, payload, options...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*api.SubmitTransactionResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(aptos.TransactionSigner, aptos.TransactionPayload, ...any) error); ok { + r1 = returnFunc(sender, payload, options...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_BuildSignAndSubmitTransaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BuildSignAndSubmitTransaction' +type MockAptosRpcClient_BuildSignAndSubmitTransaction_Call struct { + *mock.Call +} + +// BuildSignAndSubmitTransaction is a helper method to define mock.On call +// - sender aptos.TransactionSigner +// - payload aptos.TransactionPayload +// - options ...any +func (_e *MockAptosRpcClient_Expecter) BuildSignAndSubmitTransaction(sender interface{}, payload interface{}, options ...interface{}) *MockAptosRpcClient_BuildSignAndSubmitTransaction_Call { + return &MockAptosRpcClient_BuildSignAndSubmitTransaction_Call{Call: _e.mock.On("BuildSignAndSubmitTransaction", + append([]interface{}{sender, payload}, options...)...)} +} + +func (_c *MockAptosRpcClient_BuildSignAndSubmitTransaction_Call) Run(run func(sender aptos.TransactionSigner, payload aptos.TransactionPayload, options ...any)) *MockAptosRpcClient_BuildSignAndSubmitTransaction_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aptos.TransactionSigner + if args[0] != nil { + arg0 = args[0].(aptos.TransactionSigner) + } + var arg1 aptos.TransactionPayload + if args[1] != nil { + arg1 = args[1].(aptos.TransactionPayload) + } + var arg2 []any + var variadicArgs []any + if len(args) > 2 { + variadicArgs = args[2].([]any) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_BuildSignAndSubmitTransaction_Call) Return(v *api.SubmitTransactionResponse, err error) *MockAptosRpcClient_BuildSignAndSubmitTransaction_Call { + _c.Call.Return(v, err) + return _c +} + +func (_c *MockAptosRpcClient_BuildSignAndSubmitTransaction_Call) RunAndReturn(run func(sender aptos.TransactionSigner, payload aptos.TransactionPayload, options ...any) (*api.SubmitTransactionResponse, error)) *MockAptosRpcClient_BuildSignAndSubmitTransaction_Call { + _c.Call.Return(run) + return _c +} + +// BuildTransaction provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) BuildTransaction(sender aptos.AccountAddress, payload aptos.TransactionPayload, options ...any) (*aptos.RawTransaction, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(sender, payload, options) + } else { + tmpRet = _mock.Called(sender, payload) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for BuildTransaction") + } + + var r0 *aptos.RawTransaction + var r1 error + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, aptos.TransactionPayload, ...any) (*aptos.RawTransaction, error)); ok { + return returnFunc(sender, payload, options...) + } + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, aptos.TransactionPayload, ...any) *aptos.RawTransaction); ok { + r0 = returnFunc(sender, payload, options...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*aptos.RawTransaction) + } + } + if returnFunc, ok := ret.Get(1).(func(aptos.AccountAddress, aptos.TransactionPayload, ...any) error); ok { + r1 = returnFunc(sender, payload, options...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_BuildTransaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BuildTransaction' +type MockAptosRpcClient_BuildTransaction_Call struct { + *mock.Call +} + +// BuildTransaction is a helper method to define mock.On call +// - sender aptos.AccountAddress +// - payload aptos.TransactionPayload +// - options ...any +func (_e *MockAptosRpcClient_Expecter) BuildTransaction(sender interface{}, payload interface{}, options ...interface{}) *MockAptosRpcClient_BuildTransaction_Call { + return &MockAptosRpcClient_BuildTransaction_Call{Call: _e.mock.On("BuildTransaction", + append([]interface{}{sender, payload}, options...)...)} +} + +func (_c *MockAptosRpcClient_BuildTransaction_Call) Run(run func(sender aptos.AccountAddress, payload aptos.TransactionPayload, options ...any)) *MockAptosRpcClient_BuildTransaction_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aptos.AccountAddress + if args[0] != nil { + arg0 = args[0].(aptos.AccountAddress) + } + var arg1 aptos.TransactionPayload + if args[1] != nil { + arg1 = args[1].(aptos.TransactionPayload) + } + var arg2 []any + var variadicArgs []any + if len(args) > 2 { + variadicArgs = args[2].([]any) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_BuildTransaction_Call) Return(rawTransaction *aptos.RawTransaction, err error) *MockAptosRpcClient_BuildTransaction_Call { + _c.Call.Return(rawTransaction, err) + return _c +} + +func (_c *MockAptosRpcClient_BuildTransaction_Call) RunAndReturn(run func(sender aptos.AccountAddress, payload aptos.TransactionPayload, options ...any) (*aptos.RawTransaction, error)) *MockAptosRpcClient_BuildTransaction_Call { + _c.Call.Return(run) + return _c +} + +// BuildTransactionMultiAgent provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) BuildTransactionMultiAgent(sender aptos.AccountAddress, payload aptos.TransactionPayload, options ...any) (*aptos.RawTransactionWithData, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(sender, payload, options) + } else { + tmpRet = _mock.Called(sender, payload) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for BuildTransactionMultiAgent") + } + + var r0 *aptos.RawTransactionWithData + var r1 error + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, aptos.TransactionPayload, ...any) (*aptos.RawTransactionWithData, error)); ok { + return returnFunc(sender, payload, options...) + } + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, aptos.TransactionPayload, ...any) *aptos.RawTransactionWithData); ok { + r0 = returnFunc(sender, payload, options...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*aptos.RawTransactionWithData) + } + } + if returnFunc, ok := ret.Get(1).(func(aptos.AccountAddress, aptos.TransactionPayload, ...any) error); ok { + r1 = returnFunc(sender, payload, options...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_BuildTransactionMultiAgent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BuildTransactionMultiAgent' +type MockAptosRpcClient_BuildTransactionMultiAgent_Call struct { + *mock.Call +} + +// BuildTransactionMultiAgent is a helper method to define mock.On call +// - sender aptos.AccountAddress +// - payload aptos.TransactionPayload +// - options ...any +func (_e *MockAptosRpcClient_Expecter) BuildTransactionMultiAgent(sender interface{}, payload interface{}, options ...interface{}) *MockAptosRpcClient_BuildTransactionMultiAgent_Call { + return &MockAptosRpcClient_BuildTransactionMultiAgent_Call{Call: _e.mock.On("BuildTransactionMultiAgent", + append([]interface{}{sender, payload}, options...)...)} +} + +func (_c *MockAptosRpcClient_BuildTransactionMultiAgent_Call) Run(run func(sender aptos.AccountAddress, payload aptos.TransactionPayload, options ...any)) *MockAptosRpcClient_BuildTransactionMultiAgent_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aptos.AccountAddress + if args[0] != nil { + arg0 = args[0].(aptos.AccountAddress) + } + var arg1 aptos.TransactionPayload + if args[1] != nil { + arg1 = args[1].(aptos.TransactionPayload) + } + var arg2 []any + var variadicArgs []any + if len(args) > 2 { + variadicArgs = args[2].([]any) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_BuildTransactionMultiAgent_Call) Return(rawTransactionWithData *aptos.RawTransactionWithData, err error) *MockAptosRpcClient_BuildTransactionMultiAgent_Call { + _c.Call.Return(rawTransactionWithData, err) + return _c +} + +func (_c *MockAptosRpcClient_BuildTransactionMultiAgent_Call) RunAndReturn(run func(sender aptos.AccountAddress, payload aptos.TransactionPayload, options ...any) (*aptos.RawTransactionWithData, error)) *MockAptosRpcClient_BuildTransactionMultiAgent_Call { + _c.Call.Return(run) + return _c +} + +// EntryFunctionWithArgs provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) EntryFunctionWithArgs(moduleAddress aptos.AccountAddress, moduleName string, functionName string, typeArgs []any, args []any, options ...any) (*aptos.EntryFunction, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(moduleAddress, moduleName, functionName, typeArgs, args, options) + } else { + tmpRet = _mock.Called(moduleAddress, moduleName, functionName, typeArgs, args) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for EntryFunctionWithArgs") + } + + var r0 *aptos.EntryFunction + var r1 error + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, string, string, []any, []any, ...any) (*aptos.EntryFunction, error)); ok { + return returnFunc(moduleAddress, moduleName, functionName, typeArgs, args, options...) + } + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, string, string, []any, []any, ...any) *aptos.EntryFunction); ok { + r0 = returnFunc(moduleAddress, moduleName, functionName, typeArgs, args, options...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*aptos.EntryFunction) + } + } + if returnFunc, ok := ret.Get(1).(func(aptos.AccountAddress, string, string, []any, []any, ...any) error); ok { + r1 = returnFunc(moduleAddress, moduleName, functionName, typeArgs, args, options...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_EntryFunctionWithArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EntryFunctionWithArgs' +type MockAptosRpcClient_EntryFunctionWithArgs_Call struct { + *mock.Call +} + +// EntryFunctionWithArgs is a helper method to define mock.On call +// - moduleAddress aptos.AccountAddress +// - moduleName string +// - functionName string +// - typeArgs []any +// - args []any +// - options ...any +func (_e *MockAptosRpcClient_Expecter) EntryFunctionWithArgs(moduleAddress interface{}, moduleName interface{}, functionName interface{}, typeArgs interface{}, args interface{}, options ...interface{}) *MockAptosRpcClient_EntryFunctionWithArgs_Call { + return &MockAptosRpcClient_EntryFunctionWithArgs_Call{Call: _e.mock.On("EntryFunctionWithArgs", + append([]interface{}{moduleAddress, moduleName, functionName, typeArgs, args}, options...)...)} +} + +func (_c *MockAptosRpcClient_EntryFunctionWithArgs_Call) Run(run func(moduleAddress aptos.AccountAddress, moduleName string, functionName string, typeArgs []any, args []any, options ...any)) *MockAptosRpcClient_EntryFunctionWithArgs_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aptos.AccountAddress + if args[0] != nil { + arg0 = args[0].(aptos.AccountAddress) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 []any + if args[3] != nil { + arg3 = args[3].([]any) + } + var arg4 []any + if args[4] != nil { + arg4 = args[4].([]any) + } + var arg5 []any + var variadicArgs []any + if len(args) > 5 { + variadicArgs = args[5].([]any) + } + arg5 = variadicArgs + run( + arg0, + arg1, + arg2, + arg3, + arg4, + arg5..., + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_EntryFunctionWithArgs_Call) Return(entryFunction *aptos.EntryFunction, err error) *MockAptosRpcClient_EntryFunctionWithArgs_Call { + _c.Call.Return(entryFunction, err) + return _c +} + +func (_c *MockAptosRpcClient_EntryFunctionWithArgs_Call) RunAndReturn(run func(moduleAddress aptos.AccountAddress, moduleName string, functionName string, typeArgs []any, args []any, options ...any) (*aptos.EntryFunction, error)) *MockAptosRpcClient_EntryFunctionWithArgs_Call { + _c.Call.Return(run) + return _c +} + +// EstimateGasPrice provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) EstimateGasPrice() (aptos.EstimateGasInfo, error) { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for EstimateGasPrice") + } + + var r0 aptos.EstimateGasInfo + var r1 error + if returnFunc, ok := ret.Get(0).(func() (aptos.EstimateGasInfo, error)); ok { + return returnFunc() + } + if returnFunc, ok := ret.Get(0).(func() aptos.EstimateGasInfo); ok { + r0 = returnFunc() + } else { + r0 = ret.Get(0).(aptos.EstimateGasInfo) + } + if returnFunc, ok := ret.Get(1).(func() error); ok { + r1 = returnFunc() + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_EstimateGasPrice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimateGasPrice' +type MockAptosRpcClient_EstimateGasPrice_Call struct { + *mock.Call +} + +// EstimateGasPrice is a helper method to define mock.On call +func (_e *MockAptosRpcClient_Expecter) EstimateGasPrice() *MockAptosRpcClient_EstimateGasPrice_Call { + return &MockAptosRpcClient_EstimateGasPrice_Call{Call: _e.mock.On("EstimateGasPrice")} +} + +func (_c *MockAptosRpcClient_EstimateGasPrice_Call) Run(run func()) *MockAptosRpcClient_EstimateGasPrice_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAptosRpcClient_EstimateGasPrice_Call) Return(estimateGasInfo aptos.EstimateGasInfo, err error) *MockAptosRpcClient_EstimateGasPrice_Call { + _c.Call.Return(estimateGasInfo, err) + return _c +} + +func (_c *MockAptosRpcClient_EstimateGasPrice_Call) RunAndReturn(run func() (aptos.EstimateGasInfo, error)) *MockAptosRpcClient_EstimateGasPrice_Call { + _c.Call.Return(run) + return _c +} + +// EventsByCreationNumber provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) EventsByCreationNumber(account aptos.AccountAddress, creationNumber string, start *uint64, limit *uint64) ([]*api.Event, error) { + ret := _mock.Called(account, creationNumber, start, limit) + + if len(ret) == 0 { + panic("no return value specified for EventsByCreationNumber") + } + + var r0 []*api.Event + var r1 error + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, string, *uint64, *uint64) ([]*api.Event, error)); ok { + return returnFunc(account, creationNumber, start, limit) + } + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, string, *uint64, *uint64) []*api.Event); ok { + r0 = returnFunc(account, creationNumber, start, limit) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*api.Event) + } + } + if returnFunc, ok := ret.Get(1).(func(aptos.AccountAddress, string, *uint64, *uint64) error); ok { + r1 = returnFunc(account, creationNumber, start, limit) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_EventsByCreationNumber_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EventsByCreationNumber' +type MockAptosRpcClient_EventsByCreationNumber_Call struct { + *mock.Call +} + +// EventsByCreationNumber is a helper method to define mock.On call +// - account aptos.AccountAddress +// - creationNumber string +// - start *uint64 +// - limit *uint64 +func (_e *MockAptosRpcClient_Expecter) EventsByCreationNumber(account interface{}, creationNumber interface{}, start interface{}, limit interface{}) *MockAptosRpcClient_EventsByCreationNumber_Call { + return &MockAptosRpcClient_EventsByCreationNumber_Call{Call: _e.mock.On("EventsByCreationNumber", account, creationNumber, start, limit)} +} + +func (_c *MockAptosRpcClient_EventsByCreationNumber_Call) Run(run func(account aptos.AccountAddress, creationNumber string, start *uint64, limit *uint64)) *MockAptosRpcClient_EventsByCreationNumber_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aptos.AccountAddress + if args[0] != nil { + arg0 = args[0].(aptos.AccountAddress) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 *uint64 + if args[2] != nil { + arg2 = args[2].(*uint64) + } + var arg3 *uint64 + if args[3] != nil { + arg3 = args[3].(*uint64) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_EventsByCreationNumber_Call) Return(events []*api.Event, err error) *MockAptosRpcClient_EventsByCreationNumber_Call { + _c.Call.Return(events, err) + return _c +} + +func (_c *MockAptosRpcClient_EventsByCreationNumber_Call) RunAndReturn(run func(account aptos.AccountAddress, creationNumber string, start *uint64, limit *uint64) ([]*api.Event, error)) *MockAptosRpcClient_EventsByCreationNumber_Call { + _c.Call.Return(run) + return _c +} + +// EventsByHandle provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) EventsByHandle(account aptos.AccountAddress, eventHandle string, fieldName string, start *uint64, limit *uint64) ([]*api.Event, error) { + ret := _mock.Called(account, eventHandle, fieldName, start, limit) + + if len(ret) == 0 { + panic("no return value specified for EventsByHandle") + } + + var r0 []*api.Event + var r1 error + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, string, string, *uint64, *uint64) ([]*api.Event, error)); ok { + return returnFunc(account, eventHandle, fieldName, start, limit) + } + if returnFunc, ok := ret.Get(0).(func(aptos.AccountAddress, string, string, *uint64, *uint64) []*api.Event); ok { + r0 = returnFunc(account, eventHandle, fieldName, start, limit) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*api.Event) + } + } + if returnFunc, ok := ret.Get(1).(func(aptos.AccountAddress, string, string, *uint64, *uint64) error); ok { + r1 = returnFunc(account, eventHandle, fieldName, start, limit) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_EventsByHandle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EventsByHandle' +type MockAptosRpcClient_EventsByHandle_Call struct { + *mock.Call +} + +// EventsByHandle is a helper method to define mock.On call +// - account aptos.AccountAddress +// - eventHandle string +// - fieldName string +// - start *uint64 +// - limit *uint64 +func (_e *MockAptosRpcClient_Expecter) EventsByHandle(account interface{}, eventHandle interface{}, fieldName interface{}, start interface{}, limit interface{}) *MockAptosRpcClient_EventsByHandle_Call { + return &MockAptosRpcClient_EventsByHandle_Call{Call: _e.mock.On("EventsByHandle", account, eventHandle, fieldName, start, limit)} +} + +func (_c *MockAptosRpcClient_EventsByHandle_Call) Run(run func(account aptos.AccountAddress, eventHandle string, fieldName string, start *uint64, limit *uint64)) *MockAptosRpcClient_EventsByHandle_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aptos.AccountAddress + if args[0] != nil { + arg0 = args[0].(aptos.AccountAddress) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 *uint64 + if args[3] != nil { + arg3 = args[3].(*uint64) + } + var arg4 *uint64 + if args[4] != nil { + arg4 = args[4].(*uint64) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_EventsByHandle_Call) Return(events []*api.Event, err error) *MockAptosRpcClient_EventsByHandle_Call { + _c.Call.Return(events, err) + return _c +} + +func (_c *MockAptosRpcClient_EventsByHandle_Call) RunAndReturn(run func(account aptos.AccountAddress, eventHandle string, fieldName string, start *uint64, limit *uint64) ([]*api.Event, error)) *MockAptosRpcClient_EventsByHandle_Call { + _c.Call.Return(run) + return _c +} + +// GetChainId provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) GetChainId() (uint8, error) { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for GetChainId") + } + + var r0 uint8 + var r1 error + if returnFunc, ok := ret.Get(0).(func() (uint8, error)); ok { + return returnFunc() + } + if returnFunc, ok := ret.Get(0).(func() uint8); ok { + r0 = returnFunc() + } else { + r0 = ret.Get(0).(uint8) + } + if returnFunc, ok := ret.Get(1).(func() error); ok { + r1 = returnFunc() + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_GetChainId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetChainId' +type MockAptosRpcClient_GetChainId_Call struct { + *mock.Call +} + +// GetChainId is a helper method to define mock.On call +func (_e *MockAptosRpcClient_Expecter) GetChainId() *MockAptosRpcClient_GetChainId_Call { + return &MockAptosRpcClient_GetChainId_Call{Call: _e.mock.On("GetChainId")} +} + +func (_c *MockAptosRpcClient_GetChainId_Call) Run(run func()) *MockAptosRpcClient_GetChainId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAptosRpcClient_GetChainId_Call) Return(v uint8, err error) *MockAptosRpcClient_GetChainId_Call { + _c.Call.Return(v, err) + return _c +} + +func (_c *MockAptosRpcClient_GetChainId_Call) RunAndReturn(run func() (uint8, error)) *MockAptosRpcClient_GetChainId_Call { + _c.Call.Return(run) + return _c +} + +// Info provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) Info() (aptos.NodeInfo, error) { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Info") + } + + var r0 aptos.NodeInfo + var r1 error + if returnFunc, ok := ret.Get(0).(func() (aptos.NodeInfo, error)); ok { + return returnFunc() + } + if returnFunc, ok := ret.Get(0).(func() aptos.NodeInfo); ok { + r0 = returnFunc() + } else { + r0 = ret.Get(0).(aptos.NodeInfo) + } + if returnFunc, ok := ret.Get(1).(func() error); ok { + r1 = returnFunc() + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_Info_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Info' +type MockAptosRpcClient_Info_Call struct { + *mock.Call +} + +// Info is a helper method to define mock.On call +func (_e *MockAptosRpcClient_Expecter) Info() *MockAptosRpcClient_Info_Call { + return &MockAptosRpcClient_Info_Call{Call: _e.mock.On("Info")} +} + +func (_c *MockAptosRpcClient_Info_Call) Run(run func()) *MockAptosRpcClient_Info_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAptosRpcClient_Info_Call) Return(nodeInfo aptos.NodeInfo, err error) *MockAptosRpcClient_Info_Call { + _c.Call.Return(nodeInfo, err) + return _c +} + +func (_c *MockAptosRpcClient_Info_Call) RunAndReturn(run func() (aptos.NodeInfo, error)) *MockAptosRpcClient_Info_Call { + _c.Call.Return(run) + return _c +} + +// NodeAPIHealthCheck provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) NodeAPIHealthCheck(durationSecs ...uint64) (api.HealthCheckResponse, error) { + var tmpRet mock.Arguments + if len(durationSecs) > 0 { + tmpRet = _mock.Called(durationSecs) + } else { + tmpRet = _mock.Called() + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for NodeAPIHealthCheck") + } + + var r0 api.HealthCheckResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(...uint64) (api.HealthCheckResponse, error)); ok { + return returnFunc(durationSecs...) + } + if returnFunc, ok := ret.Get(0).(func(...uint64) api.HealthCheckResponse); ok { + r0 = returnFunc(durationSecs...) + } else { + r0 = ret.Get(0).(api.HealthCheckResponse) + } + if returnFunc, ok := ret.Get(1).(func(...uint64) error); ok { + r1 = returnFunc(durationSecs...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_NodeAPIHealthCheck_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NodeAPIHealthCheck' +type MockAptosRpcClient_NodeAPIHealthCheck_Call struct { + *mock.Call +} + +// NodeAPIHealthCheck is a helper method to define mock.On call +// - durationSecs ...uint64 +func (_e *MockAptosRpcClient_Expecter) NodeAPIHealthCheck(durationSecs ...interface{}) *MockAptosRpcClient_NodeAPIHealthCheck_Call { + return &MockAptosRpcClient_NodeAPIHealthCheck_Call{Call: _e.mock.On("NodeAPIHealthCheck", + append([]interface{}{}, durationSecs...)...)} +} + +func (_c *MockAptosRpcClient_NodeAPIHealthCheck_Call) Run(run func(durationSecs ...uint64)) *MockAptosRpcClient_NodeAPIHealthCheck_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 []uint64 + var variadicArgs []uint64 + if len(args) > 0 { + variadicArgs = args[0].([]uint64) + } + arg0 = variadicArgs + run( + arg0..., + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_NodeAPIHealthCheck_Call) Return(healthCheckResponse api.HealthCheckResponse, err error) *MockAptosRpcClient_NodeAPIHealthCheck_Call { + _c.Call.Return(healthCheckResponse, err) + return _c +} + +func (_c *MockAptosRpcClient_NodeAPIHealthCheck_Call) RunAndReturn(run func(durationSecs ...uint64) (api.HealthCheckResponse, error)) *MockAptosRpcClient_NodeAPIHealthCheck_Call { + _c.Call.Return(run) + return _c +} + +// PollForTransaction provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) PollForTransaction(hash string, options ...any) (*api.UserTransaction, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(hash, options) + } else { + tmpRet = _mock.Called(hash) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PollForTransaction") + } + + var r0 *api.UserTransaction + var r1 error + if returnFunc, ok := ret.Get(0).(func(string, ...any) (*api.UserTransaction, error)); ok { + return returnFunc(hash, options...) + } + if returnFunc, ok := ret.Get(0).(func(string, ...any) *api.UserTransaction); ok { + r0 = returnFunc(hash, options...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*api.UserTransaction) + } + } + if returnFunc, ok := ret.Get(1).(func(string, ...any) error); ok { + r1 = returnFunc(hash, options...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_PollForTransaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PollForTransaction' +type MockAptosRpcClient_PollForTransaction_Call struct { + *mock.Call +} + +// PollForTransaction is a helper method to define mock.On call +// - hash string +// - options ...any +func (_e *MockAptosRpcClient_Expecter) PollForTransaction(hash interface{}, options ...interface{}) *MockAptosRpcClient_PollForTransaction_Call { + return &MockAptosRpcClient_PollForTransaction_Call{Call: _e.mock.On("PollForTransaction", + append([]interface{}{hash}, options...)...)} +} + +func (_c *MockAptosRpcClient_PollForTransaction_Call) Run(run func(hash string, options ...any)) *MockAptosRpcClient_PollForTransaction_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + var arg1 []any + var variadicArgs []any + if len(args) > 1 { + variadicArgs = args[1].([]any) + } + arg1 = variadicArgs + run( + arg0, + arg1..., + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_PollForTransaction_Call) Return(userTransaction *api.UserTransaction, err error) *MockAptosRpcClient_PollForTransaction_Call { + _c.Call.Return(userTransaction, err) + return _c +} + +func (_c *MockAptosRpcClient_PollForTransaction_Call) RunAndReturn(run func(hash string, options ...any) (*api.UserTransaction, error)) *MockAptosRpcClient_PollForTransaction_Call { + _c.Call.Return(run) + return _c +} + +// PollForTransactions provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) PollForTransactions(txnHashes []string, options ...any) error { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(txnHashes, options) + } else { + tmpRet = _mock.Called(txnHashes) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PollForTransactions") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func([]string, ...any) error); ok { + r0 = returnFunc(txnHashes, options...) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// MockAptosRpcClient_PollForTransactions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PollForTransactions' +type MockAptosRpcClient_PollForTransactions_Call struct { + *mock.Call +} + +// PollForTransactions is a helper method to define mock.On call +// - txnHashes []string +// - options ...any +func (_e *MockAptosRpcClient_Expecter) PollForTransactions(txnHashes interface{}, options ...interface{}) *MockAptosRpcClient_PollForTransactions_Call { + return &MockAptosRpcClient_PollForTransactions_Call{Call: _e.mock.On("PollForTransactions", + append([]interface{}{txnHashes}, options...)...)} +} + +func (_c *MockAptosRpcClient_PollForTransactions_Call) Run(run func(txnHashes []string, options ...any)) *MockAptosRpcClient_PollForTransactions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 []string + if args[0] != nil { + arg0 = args[0].([]string) + } + var arg1 []any + var variadicArgs []any + if len(args) > 1 { + variadicArgs = args[1].([]any) + } + arg1 = variadicArgs + run( + arg0, + arg1..., + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_PollForTransactions_Call) Return(err error) *MockAptosRpcClient_PollForTransactions_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockAptosRpcClient_PollForTransactions_Call) RunAndReturn(run func(txnHashes []string, options ...any) error) *MockAptosRpcClient_PollForTransactions_Call { + _c.Call.Return(run) + return _c +} + +// RemoveHeader provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) RemoveHeader(key string) { + _mock.Called(key) + return +} + +// MockAptosRpcClient_RemoveHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveHeader' +type MockAptosRpcClient_RemoveHeader_Call struct { + *mock.Call +} + +// RemoveHeader is a helper method to define mock.On call +// - key string +func (_e *MockAptosRpcClient_Expecter) RemoveHeader(key interface{}) *MockAptosRpcClient_RemoveHeader_Call { + return &MockAptosRpcClient_RemoveHeader_Call{Call: _e.mock.On("RemoveHeader", key)} +} + +func (_c *MockAptosRpcClient_RemoveHeader_Call) Run(run func(key string)) *MockAptosRpcClient_RemoveHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_RemoveHeader_Call) Return() *MockAptosRpcClient_RemoveHeader_Call { + _c.Call.Return() + return _c +} + +func (_c *MockAptosRpcClient_RemoveHeader_Call) RunAndReturn(run func(key string)) *MockAptosRpcClient_RemoveHeader_Call { + _c.Run(run) + return _c +} + +// SetHeader provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) SetHeader(key string, value string) { + _mock.Called(key, value) + return +} + +// MockAptosRpcClient_SetHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeader' +type MockAptosRpcClient_SetHeader_Call struct { + *mock.Call +} + +// SetHeader is a helper method to define mock.On call +// - key string +// - value string +func (_e *MockAptosRpcClient_Expecter) SetHeader(key interface{}, value interface{}) *MockAptosRpcClient_SetHeader_Call { + return &MockAptosRpcClient_SetHeader_Call{Call: _e.mock.On("SetHeader", key, value)} +} + +func (_c *MockAptosRpcClient_SetHeader_Call) Run(run func(key string, value string)) *MockAptosRpcClient_SetHeader_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_SetHeader_Call) Return() *MockAptosRpcClient_SetHeader_Call { + _c.Call.Return() + return _c +} + +func (_c *MockAptosRpcClient_SetHeader_Call) RunAndReturn(run func(key string, value string)) *MockAptosRpcClient_SetHeader_Call { + _c.Run(run) + return _c +} + +// SetTimeout provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) SetTimeout(timeout time.Duration) { + _mock.Called(timeout) + return +} + +// MockAptosRpcClient_SetTimeout_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTimeout' +type MockAptosRpcClient_SetTimeout_Call struct { + *mock.Call +} + +// SetTimeout is a helper method to define mock.On call +// - timeout time.Duration +func (_e *MockAptosRpcClient_Expecter) SetTimeout(timeout interface{}) *MockAptosRpcClient_SetTimeout_Call { + return &MockAptosRpcClient_SetTimeout_Call{Call: _e.mock.On("SetTimeout", timeout)} +} + +func (_c *MockAptosRpcClient_SetTimeout_Call) Run(run func(timeout time.Duration)) *MockAptosRpcClient_SetTimeout_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 time.Duration + if args[0] != nil { + arg0 = args[0].(time.Duration) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_SetTimeout_Call) Return() *MockAptosRpcClient_SetTimeout_Call { + _c.Call.Return() + return _c +} + +func (_c *MockAptosRpcClient_SetTimeout_Call) RunAndReturn(run func(timeout time.Duration)) *MockAptosRpcClient_SetTimeout_Call { + _c.Run(run) + return _c +} + +// SimulateTransaction provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) SimulateTransaction(rawTxn *aptos.RawTransaction, sender aptos.TransactionSigner, options ...any) ([]*api.UserTransaction, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(rawTxn, sender, options) + } else { + tmpRet = _mock.Called(rawTxn, sender) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for SimulateTransaction") + } + + var r0 []*api.UserTransaction + var r1 error + if returnFunc, ok := ret.Get(0).(func(*aptos.RawTransaction, aptos.TransactionSigner, ...any) ([]*api.UserTransaction, error)); ok { + return returnFunc(rawTxn, sender, options...) + } + if returnFunc, ok := ret.Get(0).(func(*aptos.RawTransaction, aptos.TransactionSigner, ...any) []*api.UserTransaction); ok { + r0 = returnFunc(rawTxn, sender, options...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*api.UserTransaction) + } + } + if returnFunc, ok := ret.Get(1).(func(*aptos.RawTransaction, aptos.TransactionSigner, ...any) error); ok { + r1 = returnFunc(rawTxn, sender, options...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_SimulateTransaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SimulateTransaction' +type MockAptosRpcClient_SimulateTransaction_Call struct { + *mock.Call +} + +// SimulateTransaction is a helper method to define mock.On call +// - rawTxn *aptos.RawTransaction +// - sender aptos.TransactionSigner +// - options ...any +func (_e *MockAptosRpcClient_Expecter) SimulateTransaction(rawTxn interface{}, sender interface{}, options ...interface{}) *MockAptosRpcClient_SimulateTransaction_Call { + return &MockAptosRpcClient_SimulateTransaction_Call{Call: _e.mock.On("SimulateTransaction", + append([]interface{}{rawTxn, sender}, options...)...)} +} + +func (_c *MockAptosRpcClient_SimulateTransaction_Call) Run(run func(rawTxn *aptos.RawTransaction, sender aptos.TransactionSigner, options ...any)) *MockAptosRpcClient_SimulateTransaction_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *aptos.RawTransaction + if args[0] != nil { + arg0 = args[0].(*aptos.RawTransaction) + } + var arg1 aptos.TransactionSigner + if args[1] != nil { + arg1 = args[1].(aptos.TransactionSigner) + } + var arg2 []any + var variadicArgs []any + if len(args) > 2 { + variadicArgs = args[2].([]any) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_SimulateTransaction_Call) Return(userTransactions []*api.UserTransaction, err error) *MockAptosRpcClient_SimulateTransaction_Call { + _c.Call.Return(userTransactions, err) + return _c +} + +func (_c *MockAptosRpcClient_SimulateTransaction_Call) RunAndReturn(run func(rawTxn *aptos.RawTransaction, sender aptos.TransactionSigner, options ...any) ([]*api.UserTransaction, error)) *MockAptosRpcClient_SimulateTransaction_Call { + _c.Call.Return(run) + return _c +} + +// SimulateTransactionMultiAgent provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) SimulateTransactionMultiAgent(rawTxn *aptos.RawTransactionWithData, sender aptos.TransactionSigner, options ...any) ([]*api.UserTransaction, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(rawTxn, sender, options) + } else { + tmpRet = _mock.Called(rawTxn, sender) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for SimulateTransactionMultiAgent") + } + + var r0 []*api.UserTransaction + var r1 error + if returnFunc, ok := ret.Get(0).(func(*aptos.RawTransactionWithData, aptos.TransactionSigner, ...any) ([]*api.UserTransaction, error)); ok { + return returnFunc(rawTxn, sender, options...) + } + if returnFunc, ok := ret.Get(0).(func(*aptos.RawTransactionWithData, aptos.TransactionSigner, ...any) []*api.UserTransaction); ok { + r0 = returnFunc(rawTxn, sender, options...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*api.UserTransaction) + } + } + if returnFunc, ok := ret.Get(1).(func(*aptos.RawTransactionWithData, aptos.TransactionSigner, ...any) error); ok { + r1 = returnFunc(rawTxn, sender, options...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_SimulateTransactionMultiAgent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SimulateTransactionMultiAgent' +type MockAptosRpcClient_SimulateTransactionMultiAgent_Call struct { + *mock.Call +} + +// SimulateTransactionMultiAgent is a helper method to define mock.On call +// - rawTxn *aptos.RawTransactionWithData +// - sender aptos.TransactionSigner +// - options ...any +func (_e *MockAptosRpcClient_Expecter) SimulateTransactionMultiAgent(rawTxn interface{}, sender interface{}, options ...interface{}) *MockAptosRpcClient_SimulateTransactionMultiAgent_Call { + return &MockAptosRpcClient_SimulateTransactionMultiAgent_Call{Call: _e.mock.On("SimulateTransactionMultiAgent", + append([]interface{}{rawTxn, sender}, options...)...)} +} + +func (_c *MockAptosRpcClient_SimulateTransactionMultiAgent_Call) Run(run func(rawTxn *aptos.RawTransactionWithData, sender aptos.TransactionSigner, options ...any)) *MockAptosRpcClient_SimulateTransactionMultiAgent_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *aptos.RawTransactionWithData + if args[0] != nil { + arg0 = args[0].(*aptos.RawTransactionWithData) + } + var arg1 aptos.TransactionSigner + if args[1] != nil { + arg1 = args[1].(aptos.TransactionSigner) + } + var arg2 []any + var variadicArgs []any + if len(args) > 2 { + variadicArgs = args[2].([]any) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_SimulateTransactionMultiAgent_Call) Return(userTransactions []*api.UserTransaction, err error) *MockAptosRpcClient_SimulateTransactionMultiAgent_Call { + _c.Call.Return(userTransactions, err) + return _c +} + +func (_c *MockAptosRpcClient_SimulateTransactionMultiAgent_Call) RunAndReturn(run func(rawTxn *aptos.RawTransactionWithData, sender aptos.TransactionSigner, options ...any) ([]*api.UserTransaction, error)) *MockAptosRpcClient_SimulateTransactionMultiAgent_Call { + _c.Call.Return(run) + return _c +} + +// SubmitTransaction provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) SubmitTransaction(signedTransaction *aptos.SignedTransaction) (*api.SubmitTransactionResponse, error) { + ret := _mock.Called(signedTransaction) + + if len(ret) == 0 { + panic("no return value specified for SubmitTransaction") + } + + var r0 *api.SubmitTransactionResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(*aptos.SignedTransaction) (*api.SubmitTransactionResponse, error)); ok { + return returnFunc(signedTransaction) + } + if returnFunc, ok := ret.Get(0).(func(*aptos.SignedTransaction) *api.SubmitTransactionResponse); ok { + r0 = returnFunc(signedTransaction) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*api.SubmitTransactionResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(*aptos.SignedTransaction) error); ok { + r1 = returnFunc(signedTransaction) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_SubmitTransaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubmitTransaction' +type MockAptosRpcClient_SubmitTransaction_Call struct { + *mock.Call +} + +// SubmitTransaction is a helper method to define mock.On call +// - signedTransaction *aptos.SignedTransaction +func (_e *MockAptosRpcClient_Expecter) SubmitTransaction(signedTransaction interface{}) *MockAptosRpcClient_SubmitTransaction_Call { + return &MockAptosRpcClient_SubmitTransaction_Call{Call: _e.mock.On("SubmitTransaction", signedTransaction)} +} + +func (_c *MockAptosRpcClient_SubmitTransaction_Call) Run(run func(signedTransaction *aptos.SignedTransaction)) *MockAptosRpcClient_SubmitTransaction_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *aptos.SignedTransaction + if args[0] != nil { + arg0 = args[0].(*aptos.SignedTransaction) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_SubmitTransaction_Call) Return(v *api.SubmitTransactionResponse, err error) *MockAptosRpcClient_SubmitTransaction_Call { + _c.Call.Return(v, err) + return _c +} + +func (_c *MockAptosRpcClient_SubmitTransaction_Call) RunAndReturn(run func(signedTransaction *aptos.SignedTransaction) (*api.SubmitTransactionResponse, error)) *MockAptosRpcClient_SubmitTransaction_Call { + _c.Call.Return(run) + return _c +} + +// TransactionByHash provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) TransactionByHash(txnHash string) (*api.Transaction, error) { + ret := _mock.Called(txnHash) + + if len(ret) == 0 { + panic("no return value specified for TransactionByHash") + } + + var r0 *api.Transaction + var r1 error + if returnFunc, ok := ret.Get(0).(func(string) (*api.Transaction, error)); ok { + return returnFunc(txnHash) + } + if returnFunc, ok := ret.Get(0).(func(string) *api.Transaction); ok { + r0 = returnFunc(txnHash) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*api.Transaction) + } + } + if returnFunc, ok := ret.Get(1).(func(string) error); ok { + r1 = returnFunc(txnHash) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_TransactionByHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransactionByHash' +type MockAptosRpcClient_TransactionByHash_Call struct { + *mock.Call +} + +// TransactionByHash is a helper method to define mock.On call +// - txnHash string +func (_e *MockAptosRpcClient_Expecter) TransactionByHash(txnHash interface{}) *MockAptosRpcClient_TransactionByHash_Call { + return &MockAptosRpcClient_TransactionByHash_Call{Call: _e.mock.On("TransactionByHash", txnHash)} +} + +func (_c *MockAptosRpcClient_TransactionByHash_Call) Run(run func(txnHash string)) *MockAptosRpcClient_TransactionByHash_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_TransactionByHash_Call) Return(transaction *api.Transaction, err error) *MockAptosRpcClient_TransactionByHash_Call { + _c.Call.Return(transaction, err) + return _c +} + +func (_c *MockAptosRpcClient_TransactionByHash_Call) RunAndReturn(run func(txnHash string) (*api.Transaction, error)) *MockAptosRpcClient_TransactionByHash_Call { + _c.Call.Return(run) + return _c +} + +// TransactionByVersion provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) TransactionByVersion(version uint64) (*api.CommittedTransaction, error) { + ret := _mock.Called(version) + + if len(ret) == 0 { + panic("no return value specified for TransactionByVersion") + } + + var r0 *api.CommittedTransaction + var r1 error + if returnFunc, ok := ret.Get(0).(func(uint64) (*api.CommittedTransaction, error)); ok { + return returnFunc(version) + } + if returnFunc, ok := ret.Get(0).(func(uint64) *api.CommittedTransaction); ok { + r0 = returnFunc(version) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*api.CommittedTransaction) + } + } + if returnFunc, ok := ret.Get(1).(func(uint64) error); ok { + r1 = returnFunc(version) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_TransactionByVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransactionByVersion' +type MockAptosRpcClient_TransactionByVersion_Call struct { + *mock.Call +} + +// TransactionByVersion is a helper method to define mock.On call +// - version uint64 +func (_e *MockAptosRpcClient_Expecter) TransactionByVersion(version interface{}) *MockAptosRpcClient_TransactionByVersion_Call { + return &MockAptosRpcClient_TransactionByVersion_Call{Call: _e.mock.On("TransactionByVersion", version)} +} + +func (_c *MockAptosRpcClient_TransactionByVersion_Call) Run(run func(version uint64)) *MockAptosRpcClient_TransactionByVersion_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 uint64 + if args[0] != nil { + arg0 = args[0].(uint64) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_TransactionByVersion_Call) Return(committedTransaction *api.CommittedTransaction, err error) *MockAptosRpcClient_TransactionByVersion_Call { + _c.Call.Return(committedTransaction, err) + return _c +} + +func (_c *MockAptosRpcClient_TransactionByVersion_Call) RunAndReturn(run func(version uint64) (*api.CommittedTransaction, error)) *MockAptosRpcClient_TransactionByVersion_Call { + _c.Call.Return(run) + return _c +} + +// Transactions provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) Transactions(start *uint64, limit *uint64) ([]*api.CommittedTransaction, error) { + ret := _mock.Called(start, limit) + + if len(ret) == 0 { + panic("no return value specified for Transactions") + } + + var r0 []*api.CommittedTransaction + var r1 error + if returnFunc, ok := ret.Get(0).(func(*uint64, *uint64) ([]*api.CommittedTransaction, error)); ok { + return returnFunc(start, limit) + } + if returnFunc, ok := ret.Get(0).(func(*uint64, *uint64) []*api.CommittedTransaction); ok { + r0 = returnFunc(start, limit) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*api.CommittedTransaction) + } + } + if returnFunc, ok := ret.Get(1).(func(*uint64, *uint64) error); ok { + r1 = returnFunc(start, limit) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_Transactions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Transactions' +type MockAptosRpcClient_Transactions_Call struct { + *mock.Call +} + +// Transactions is a helper method to define mock.On call +// - start *uint64 +// - limit *uint64 +func (_e *MockAptosRpcClient_Expecter) Transactions(start interface{}, limit interface{}) *MockAptosRpcClient_Transactions_Call { + return &MockAptosRpcClient_Transactions_Call{Call: _e.mock.On("Transactions", start, limit)} +} + +func (_c *MockAptosRpcClient_Transactions_Call) Run(run func(start *uint64, limit *uint64)) *MockAptosRpcClient_Transactions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *uint64 + if args[0] != nil { + arg0 = args[0].(*uint64) + } + var arg1 *uint64 + if args[1] != nil { + arg1 = args[1].(*uint64) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_Transactions_Call) Return(committedTransactions []*api.CommittedTransaction, err error) *MockAptosRpcClient_Transactions_Call { + _c.Call.Return(committedTransactions, err) + return _c +} + +func (_c *MockAptosRpcClient_Transactions_Call) RunAndReturn(run func(start *uint64, limit *uint64) ([]*api.CommittedTransaction, error)) *MockAptosRpcClient_Transactions_Call { + _c.Call.Return(run) + return _c +} + +// View provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) View(payload *aptos.ViewPayload, ledgerVersion ...uint64) ([]any, error) { + var tmpRet mock.Arguments + if len(ledgerVersion) > 0 { + tmpRet = _mock.Called(payload, ledgerVersion) + } else { + tmpRet = _mock.Called(payload) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for View") + } + + var r0 []any + var r1 error + if returnFunc, ok := ret.Get(0).(func(*aptos.ViewPayload, ...uint64) ([]any, error)); ok { + return returnFunc(payload, ledgerVersion...) + } + if returnFunc, ok := ret.Get(0).(func(*aptos.ViewPayload, ...uint64) []any); ok { + r0 = returnFunc(payload, ledgerVersion...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]any) + } + } + if returnFunc, ok := ret.Get(1).(func(*aptos.ViewPayload, ...uint64) error); ok { + r1 = returnFunc(payload, ledgerVersion...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_View_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'View' +type MockAptosRpcClient_View_Call struct { + *mock.Call +} + +// View is a helper method to define mock.On call +// - payload *aptos.ViewPayload +// - ledgerVersion ...uint64 +func (_e *MockAptosRpcClient_Expecter) View(payload interface{}, ledgerVersion ...interface{}) *MockAptosRpcClient_View_Call { + return &MockAptosRpcClient_View_Call{Call: _e.mock.On("View", + append([]interface{}{payload}, ledgerVersion...)...)} +} + +func (_c *MockAptosRpcClient_View_Call) Run(run func(payload *aptos.ViewPayload, ledgerVersion ...uint64)) *MockAptosRpcClient_View_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *aptos.ViewPayload + if args[0] != nil { + arg0 = args[0].(*aptos.ViewPayload) + } + var arg1 []uint64 + var variadicArgs []uint64 + if len(args) > 1 { + variadicArgs = args[1].([]uint64) + } + arg1 = variadicArgs + run( + arg0, + arg1..., + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_View_Call) Return(vs []any, err error) *MockAptosRpcClient_View_Call { + _c.Call.Return(vs, err) + return _c +} + +func (_c *MockAptosRpcClient_View_Call) RunAndReturn(run func(payload *aptos.ViewPayload, ledgerVersion ...uint64) ([]any, error)) *MockAptosRpcClient_View_Call { + _c.Call.Return(run) + return _c +} + +// WaitForTransaction provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) WaitForTransaction(txnHash string, options ...any) (*api.UserTransaction, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(txnHash, options) + } else { + tmpRet = _mock.Called(txnHash) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for WaitForTransaction") + } + + var r0 *api.UserTransaction + var r1 error + if returnFunc, ok := ret.Get(0).(func(string, ...any) (*api.UserTransaction, error)); ok { + return returnFunc(txnHash, options...) + } + if returnFunc, ok := ret.Get(0).(func(string, ...any) *api.UserTransaction); ok { + r0 = returnFunc(txnHash, options...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*api.UserTransaction) + } + } + if returnFunc, ok := ret.Get(1).(func(string, ...any) error); ok { + r1 = returnFunc(txnHash, options...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_WaitForTransaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitForTransaction' +type MockAptosRpcClient_WaitForTransaction_Call struct { + *mock.Call +} + +// WaitForTransaction is a helper method to define mock.On call +// - txnHash string +// - options ...any +func (_e *MockAptosRpcClient_Expecter) WaitForTransaction(txnHash interface{}, options ...interface{}) *MockAptosRpcClient_WaitForTransaction_Call { + return &MockAptosRpcClient_WaitForTransaction_Call{Call: _e.mock.On("WaitForTransaction", + append([]interface{}{txnHash}, options...)...)} +} + +func (_c *MockAptosRpcClient_WaitForTransaction_Call) Run(run func(txnHash string, options ...any)) *MockAptosRpcClient_WaitForTransaction_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + var arg1 []any + var variadicArgs []any + if len(args) > 1 { + variadicArgs = args[1].([]any) + } + arg1 = variadicArgs + run( + arg0, + arg1..., + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_WaitForTransaction_Call) Return(userTransaction *api.UserTransaction, err error) *MockAptosRpcClient_WaitForTransaction_Call { + _c.Call.Return(userTransaction, err) + return _c +} + +func (_c *MockAptosRpcClient_WaitForTransaction_Call) RunAndReturn(run func(txnHash string, options ...any) (*api.UserTransaction, error)) *MockAptosRpcClient_WaitForTransaction_Call { + _c.Call.Return(run) + return _c +} + +// WaitTransactionByHash provides a mock function for the type MockAptosRpcClient +func (_mock *MockAptosRpcClient) WaitTransactionByHash(txnHash string) (*api.Transaction, error) { + ret := _mock.Called(txnHash) + + if len(ret) == 0 { + panic("no return value specified for WaitTransactionByHash") + } + + var r0 *api.Transaction + var r1 error + if returnFunc, ok := ret.Get(0).(func(string) (*api.Transaction, error)); ok { + return returnFunc(txnHash) + } + if returnFunc, ok := ret.Get(0).(func(string) *api.Transaction); ok { + r0 = returnFunc(txnHash) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*api.Transaction) + } + } + if returnFunc, ok := ret.Get(1).(func(string) error); ok { + r1 = returnFunc(txnHash) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAptosRpcClient_WaitTransactionByHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitTransactionByHash' +type MockAptosRpcClient_WaitTransactionByHash_Call struct { + *mock.Call +} + +// WaitTransactionByHash is a helper method to define mock.On call +// - txnHash string +func (_e *MockAptosRpcClient_Expecter) WaitTransactionByHash(txnHash interface{}) *MockAptosRpcClient_WaitTransactionByHash_Call { + return &MockAptosRpcClient_WaitTransactionByHash_Call{Call: _e.mock.On("WaitTransactionByHash", txnHash)} +} + +func (_c *MockAptosRpcClient_WaitTransactionByHash_Call) Run(run func(txnHash string)) *MockAptosRpcClient_WaitTransactionByHash_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockAptosRpcClient_WaitTransactionByHash_Call) Return(transaction *api.Transaction, err error) *MockAptosRpcClient_WaitTransactionByHash_Call { + _c.Call.Return(transaction, err) + return _c +} + +func (_c *MockAptosRpcClient_WaitTransactionByHash_Call) RunAndReturn(run func(txnHash string) (*api.Transaction, error)) *MockAptosRpcClient_WaitTransactionByHash_Call { + _c.Call.Return(run) + return _c +} diff --git a/chain/aptos/mocks/transaction_signer.go b/chain/aptos/mocks/transaction_signer.go new file mode 100644 index 000000000..14adf3067 --- /dev/null +++ b/chain/aptos/mocks/transaction_signer.go @@ -0,0 +1,346 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify + +package mocks + +import ( + "github.com/aptos-labs/aptos-go-sdk" + "github.com/aptos-labs/aptos-go-sdk/crypto" + mock "github.com/stretchr/testify/mock" +) + +// NewMockTransactionSigner creates a new instance of MockTransactionSigner. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockTransactionSigner(t interface { + mock.TestingT + Cleanup(func()) +}) *MockTransactionSigner { + mock := &MockTransactionSigner{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + +// MockTransactionSigner is an autogenerated mock type for the TransactionSigner type +type MockTransactionSigner struct { + mock.Mock +} + +type MockTransactionSigner_Expecter struct { + mock *mock.Mock +} + +func (_m *MockTransactionSigner) EXPECT() *MockTransactionSigner_Expecter { + return &MockTransactionSigner_Expecter{mock: &_m.Mock} +} + +// AccountAddress provides a mock function for the type MockTransactionSigner +func (_mock *MockTransactionSigner) AccountAddress() aptos.AccountAddress { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for AccountAddress") + } + + var r0 aptos.AccountAddress + if returnFunc, ok := ret.Get(0).(func() aptos.AccountAddress); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(aptos.AccountAddress) + } + } + return r0 +} + +// MockTransactionSigner_AccountAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AccountAddress' +type MockTransactionSigner_AccountAddress_Call struct { + *mock.Call +} + +// AccountAddress is a helper method to define mock.On call +func (_e *MockTransactionSigner_Expecter) AccountAddress() *MockTransactionSigner_AccountAddress_Call { + return &MockTransactionSigner_AccountAddress_Call{Call: _e.mock.On("AccountAddress")} +} + +func (_c *MockTransactionSigner_AccountAddress_Call) Run(run func()) *MockTransactionSigner_AccountAddress_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockTransactionSigner_AccountAddress_Call) Return(v aptos.AccountAddress) *MockTransactionSigner_AccountAddress_Call { + _c.Call.Return(v) + return _c +} + +func (_c *MockTransactionSigner_AccountAddress_Call) RunAndReturn(run func() aptos.AccountAddress) *MockTransactionSigner_AccountAddress_Call { + _c.Call.Return(run) + return _c +} + +// AuthKey provides a mock function for the type MockTransactionSigner +func (_mock *MockTransactionSigner) AuthKey() *crypto.AuthenticationKey { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for AuthKey") + } + + var r0 *crypto.AuthenticationKey + if returnFunc, ok := ret.Get(0).(func() *crypto.AuthenticationKey); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*crypto.AuthenticationKey) + } + } + return r0 +} + +// MockTransactionSigner_AuthKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthKey' +type MockTransactionSigner_AuthKey_Call struct { + *mock.Call +} + +// AuthKey is a helper method to define mock.On call +func (_e *MockTransactionSigner_Expecter) AuthKey() *MockTransactionSigner_AuthKey_Call { + return &MockTransactionSigner_AuthKey_Call{Call: _e.mock.On("AuthKey")} +} + +func (_c *MockTransactionSigner_AuthKey_Call) Run(run func()) *MockTransactionSigner_AuthKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockTransactionSigner_AuthKey_Call) Return(authenticationKey *crypto.AuthenticationKey) *MockTransactionSigner_AuthKey_Call { + _c.Call.Return(authenticationKey) + return _c +} + +func (_c *MockTransactionSigner_AuthKey_Call) RunAndReturn(run func() *crypto.AuthenticationKey) *MockTransactionSigner_AuthKey_Call { + _c.Call.Return(run) + return _c +} + +// PubKey provides a mock function for the type MockTransactionSigner +func (_mock *MockTransactionSigner) PubKey() crypto.PublicKey { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for PubKey") + } + + var r0 crypto.PublicKey + if returnFunc, ok := ret.Get(0).(func() crypto.PublicKey); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(crypto.PublicKey) + } + } + return r0 +} + +// MockTransactionSigner_PubKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PubKey' +type MockTransactionSigner_PubKey_Call struct { + *mock.Call +} + +// PubKey is a helper method to define mock.On call +func (_e *MockTransactionSigner_Expecter) PubKey() *MockTransactionSigner_PubKey_Call { + return &MockTransactionSigner_PubKey_Call{Call: _e.mock.On("PubKey")} +} + +func (_c *MockTransactionSigner_PubKey_Call) Run(run func()) *MockTransactionSigner_PubKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockTransactionSigner_PubKey_Call) Return(publicKey crypto.PublicKey) *MockTransactionSigner_PubKey_Call { + _c.Call.Return(publicKey) + return _c +} + +func (_c *MockTransactionSigner_PubKey_Call) RunAndReturn(run func() crypto.PublicKey) *MockTransactionSigner_PubKey_Call { + _c.Call.Return(run) + return _c +} + +// Sign provides a mock function for the type MockTransactionSigner +func (_mock *MockTransactionSigner) Sign(msg []byte) (*crypto.AccountAuthenticator, error) { + ret := _mock.Called(msg) + + if len(ret) == 0 { + panic("no return value specified for Sign") + } + + var r0 *crypto.AccountAuthenticator + var r1 error + if returnFunc, ok := ret.Get(0).(func([]byte) (*crypto.AccountAuthenticator, error)); ok { + return returnFunc(msg) + } + if returnFunc, ok := ret.Get(0).(func([]byte) *crypto.AccountAuthenticator); ok { + r0 = returnFunc(msg) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*crypto.AccountAuthenticator) + } + } + if returnFunc, ok := ret.Get(1).(func([]byte) error); ok { + r1 = returnFunc(msg) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockTransactionSigner_Sign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sign' +type MockTransactionSigner_Sign_Call struct { + *mock.Call +} + +// Sign is a helper method to define mock.On call +// - msg []byte +func (_e *MockTransactionSigner_Expecter) Sign(msg interface{}) *MockTransactionSigner_Sign_Call { + return &MockTransactionSigner_Sign_Call{Call: _e.mock.On("Sign", msg)} +} + +func (_c *MockTransactionSigner_Sign_Call) Run(run func(msg []byte)) *MockTransactionSigner_Sign_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 []byte + if args[0] != nil { + arg0 = args[0].([]byte) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockTransactionSigner_Sign_Call) Return(authenticator *crypto.AccountAuthenticator, err error) *MockTransactionSigner_Sign_Call { + _c.Call.Return(authenticator, err) + return _c +} + +func (_c *MockTransactionSigner_Sign_Call) RunAndReturn(run func(msg []byte) (*crypto.AccountAuthenticator, error)) *MockTransactionSigner_Sign_Call { + _c.Call.Return(run) + return _c +} + +// SignMessage provides a mock function for the type MockTransactionSigner +func (_mock *MockTransactionSigner) SignMessage(msg []byte) (crypto.Signature, error) { + ret := _mock.Called(msg) + + if len(ret) == 0 { + panic("no return value specified for SignMessage") + } + + var r0 crypto.Signature + var r1 error + if returnFunc, ok := ret.Get(0).(func([]byte) (crypto.Signature, error)); ok { + return returnFunc(msg) + } + if returnFunc, ok := ret.Get(0).(func([]byte) crypto.Signature); ok { + r0 = returnFunc(msg) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(crypto.Signature) + } + } + if returnFunc, ok := ret.Get(1).(func([]byte) error); ok { + r1 = returnFunc(msg) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockTransactionSigner_SignMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignMessage' +type MockTransactionSigner_SignMessage_Call struct { + *mock.Call +} + +// SignMessage is a helper method to define mock.On call +// - msg []byte +func (_e *MockTransactionSigner_Expecter) SignMessage(msg interface{}) *MockTransactionSigner_SignMessage_Call { + return &MockTransactionSigner_SignMessage_Call{Call: _e.mock.On("SignMessage", msg)} +} + +func (_c *MockTransactionSigner_SignMessage_Call) Run(run func(msg []byte)) *MockTransactionSigner_SignMessage_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 []byte + if args[0] != nil { + arg0 = args[0].([]byte) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockTransactionSigner_SignMessage_Call) Return(signature crypto.Signature, err error) *MockTransactionSigner_SignMessage_Call { + _c.Call.Return(signature, err) + return _c +} + +func (_c *MockTransactionSigner_SignMessage_Call) RunAndReturn(run func(msg []byte) (crypto.Signature, error)) *MockTransactionSigner_SignMessage_Call { + _c.Call.Return(run) + return _c +} + +// SimulationAuthenticator provides a mock function for the type MockTransactionSigner +func (_mock *MockTransactionSigner) SimulationAuthenticator() *crypto.AccountAuthenticator { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for SimulationAuthenticator") + } + + var r0 *crypto.AccountAuthenticator + if returnFunc, ok := ret.Get(0).(func() *crypto.AccountAuthenticator); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*crypto.AccountAuthenticator) + } + } + return r0 +} + +// MockTransactionSigner_SimulationAuthenticator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SimulationAuthenticator' +type MockTransactionSigner_SimulationAuthenticator_Call struct { + *mock.Call +} + +// SimulationAuthenticator is a helper method to define mock.On call +func (_e *MockTransactionSigner_Expecter) SimulationAuthenticator() *MockTransactionSigner_SimulationAuthenticator_Call { + return &MockTransactionSigner_SimulationAuthenticator_Call{Call: _e.mock.On("SimulationAuthenticator")} +} + +func (_c *MockTransactionSigner_SimulationAuthenticator_Call) Run(run func()) *MockTransactionSigner_SimulationAuthenticator_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockTransactionSigner_SimulationAuthenticator_Call) Return(accountAuthenticator *crypto.AccountAuthenticator) *MockTransactionSigner_SimulationAuthenticator_Call { + _c.Call.Return(accountAuthenticator) + return _c +} + +func (_c *MockTransactionSigner_SimulationAuthenticator_Call) RunAndReturn(run func() *crypto.AccountAuthenticator) *MockTransactionSigner_SimulationAuthenticator_Call { + _c.Call.Return(run) + return _c +} diff --git a/chain/mcms/adapters/chain_access.go b/chain/mcms/adapters/chain_access.go index 8b0d1cf0c..16670951e 100644 --- a/chain/mcms/adapters/chain_access.go +++ b/chain/mcms/adapters/chain_access.go @@ -3,11 +3,14 @@ package adapters import ( aptoslib "github.com/aptos-labs/aptos-go-sdk" "github.com/block-vision/sui-go-sdk/sui" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + sol "github.com/gagliardetto/solana-go" solrpc "github.com/gagliardetto/solana-go/rpc" "github.com/smartcontractkit/mcms/sdk/evm" mcmssui "github.com/smartcontractkit/mcms/sdk/sui" "github.com/stellar/go-stellar-sdk/clients/rpcclient" "github.com/xssnick/tonutils-go/ton" + tonwallet "github.com/xssnick/tonutils-go/ton/wallet" "github.com/smartcontractkit/chainlink-deployments-framework/chain" cldfaptos "github.com/smartcontractkit/chainlink-deployments-framework/chain/aptos" @@ -56,6 +59,12 @@ func (a *ChainAccessAdapter) EVMClient(selector uint64) (evm.ContractDeployBacke return ch.Client, true } +// EVMSigner returns an EVM signer for the given selector. +func (a *ChainAccessAdapter) EVMSigner(selector uint64) (*bind.TransactOpts, bool) { + ch, ok := a.inner.EVMChains()[selector] + return ch.DeployerKey, ok +} + // SolanaClient returns the Solana RPC client for the given selector. func (a *ChainAccessAdapter) SolanaClient(selector uint64) (*solrpc.Client, bool) { ch, ok := a.inner.SolanaChains()[selector] @@ -66,6 +75,12 @@ func (a *ChainAccessAdapter) SolanaClient(selector uint64) (*solrpc.Client, bool return ch.Client, true } +// SolanaSigner returns the Solana signer for the given selector. +func (a *ChainAccessAdapter) SolanaSigner(selector uint64) (*sol.PrivateKey, bool) { + ch, ok := a.inner.SolanaChains()[selector] + return ch.DeployerKey, ok +} + // AptosClient returns the Aptos RPC client for the given selector. func (a *ChainAccessAdapter) AptosClient(selector uint64) (aptoslib.AptosRpcClient, bool) { ch, ok := a.inner.AptosChains()[selector] @@ -76,14 +91,26 @@ func (a *ChainAccessAdapter) AptosClient(selector uint64) (aptoslib.AptosRpcClie return ch.Client, true } -// SuiClient returns the Sui API client and signer for the given selector. -func (a *ChainAccessAdapter) SuiClient(selector uint64) (sui.ISuiAPI, mcmssui.SuiSigner, bool) { +// AptosSigner returns the Aptos signer for the given selector. +func (a *ChainAccessAdapter) AptosSigner(selector uint64) (aptoslib.TransactionSigner, bool) { + ch, ok := a.inner.AptosChains()[selector] + return ch.DeployerSigner, ok +} + +// SuiClient returns the Sui API client for the given selector. +func (a *ChainAccessAdapter) SuiClient(selector uint64) (sui.ISuiAPI, bool) { ch, ok := a.inner.SuiChains()[selector] if !ok { - return nil, nil, false + return nil, false } - return ch.Client, ch.Signer, true + return ch.Client, true +} + +// SuiSigner returns the Sui signer for the given selector. +func (a *ChainAccessAdapter) SuiSigner(selector uint64) (mcmssui.SuiSigner, bool) { + ch, ok := a.inner.SuiChains()[selector] + return ch.Signer, ok } // TonClient returns the Ton API client for the given selector. @@ -96,6 +123,12 @@ func (a *ChainAccessAdapter) TonClient(selector uint64) (ton.APIClientWrapped, b return ch.Client, true } +// TonSigner returns the Ton signer for the given selector. +func (a *ChainAccessAdapter) TonSigner(selector uint64) (*tonwallet.Wallet, bool) { + ch, ok := a.inner.TonChains()[selector] + return ch.Wallet, ok +} + // StellarClient returns the Stellar RPC client for the given selector. func (a *ChainAccessAdapter) StellarClient(selector uint64) (*rpcclient.Client, bool) { ch, ok := a.inner.StellarChains()[selector] @@ -106,6 +139,12 @@ func (a *ChainAccessAdapter) StellarClient(selector uint64) (*rpcclient.Client, return ch.Client, true } +// StellarSigner returns the Stellar signer for the given selector. +func (a *ChainAccessAdapter) StellarSigner(selector uint64) (cldfstellar.StellarSigner, bool) { + ch, ok := a.inner.StellarChains()[selector] + return ch.Signer, ok +} + // CantonChain returns the Canton chain for the given selector. // Canton chains contain participants with their own service clients, so we return the chain itself. func (a *ChainAccessAdapter) CantonChain(selector uint64) (cldfcanton.Chain, bool) { diff --git a/chain/mcms/adapters/chain_access_test.go b/chain/mcms/adapters/chain_access_test.go index 97b334aef..e1b553396 100644 --- a/chain/mcms/adapters/chain_access_test.go +++ b/chain/mcms/adapters/chain_access_test.go @@ -3,17 +3,24 @@ package adapters import ( "testing" + gethbind "github.com/ethereum/go-ethereum/accounts/abi/bind" + gethcommon "github.com/ethereum/go-ethereum/common" + sol "github.com/gagliardetto/solana-go" solrpc "github.com/gagliardetto/solana-go/rpc" "github.com/stretchr/testify/require" + tonwallet "github.com/xssnick/tonutils-go/ton/wallet" "github.com/smartcontractkit/chainlink-deployments-framework/chain" "github.com/smartcontractkit/chainlink-deployments-framework/chain/aptos" + aptosmocks "github.com/smartcontractkit/chainlink-deployments-framework/chain/aptos/mocks" chaincanton "github.com/smartcontractkit/chainlink-deployments-framework/chain/canton" "github.com/smartcontractkit/chainlink-deployments-framework/chain/evm" "github.com/smartcontractkit/chainlink-deployments-framework/chain/solana" "github.com/smartcontractkit/chainlink-deployments-framework/chain/stellar" chainsui "github.com/smartcontractkit/chainlink-deployments-framework/chain/sui" + suimocks "github.com/smartcontractkit/chainlink-deployments-framework/chain/sui/mocks" "github.com/smartcontractkit/chainlink-deployments-framework/chain/ton" + tonmocks "github.com/smartcontractkit/chainlink-deployments-framework/chain/ton/mocks" ) func TestChainAccess_UnknownSelector(t *testing.T) { @@ -25,23 +32,42 @@ func TestChainAccess_UnknownSelector(t *testing.T) { require.False(t, ok) require.Nil(t, evmClient) + evmSigner, ok := a.EVMSigner(999) + require.False(t, ok) + require.Nil(t, evmSigner) + solClient, ok := a.SolanaClient(999) require.False(t, ok) require.Nil(t, solClient) + solSigner, ok := a.SolanaSigner(999) + require.False(t, ok) + require.Nil(t, solSigner) + aptosClient, ok := a.AptosClient(999) require.False(t, ok) require.Nil(t, aptosClient) - suiClient, suiSigner, ok := a.SuiClient(999) + aptosSigner, ok := a.AptosSigner(999) + require.False(t, ok) + require.Nil(t, aptosSigner) + + suiClient, ok := a.SuiClient(999) require.False(t, ok) require.Nil(t, suiClient) + + suiSigner, ok := a.SuiSigner(999) + require.False(t, ok) require.Nil(t, suiSigner) tonClient, ok := a.TonClient(999) require.False(t, ok) require.Nil(t, tonClient) + tonSigner, ok := a.TonSigner(999) + require.False(t, ok) + require.Nil(t, tonSigner) + cantonChain, ok := a.CantonChain(999) require.False(t, ok) require.Equal(t, chaincanton.Chain{}, cantonChain) @@ -60,21 +86,23 @@ func TestChainAccess_SelectorsAndLookups(t *testing.T) { cantonSel = uint64(777) ) - evmOnchain := evm.NewMockOnchainClient(t) + evmClient := evm.NewMockOnchainClient(t) + evmSigner := &gethbind.TransactOpts{From: gethcommon.HexToAddress("0x123")} + aptosClient := aptosmocks.NewMockAptosRpcClient(t) + aptosSigner := aptosmocks.NewMockTransactionSigner(t) solClient := solrpc.New("http://example.invalid") - suiSigner, err := chainsui.NewSignerFromSeed(make([]byte, 32)) - require.NoError(t, err) + solSigner := &sol.PrivateKey{1, 2, 3} + suiClient := suimocks.NewMockISuiAPI(t) + suiSigner, _ := chainsui.NewSignerFromSeed(make([]byte, 32)) + tonClient := tonmocks.NewMockAPIClientWrapped(t) + tonSigner := &tonwallet.Wallet{} chains := chain.NewBlockChains(map[uint64]chain.BlockChain{ - evmSel: evm.Chain{Selector: evmSel, Client: evmOnchain}, - solSel: solana.Chain{Selector: solSel, Client: solClient}, - aptosSel: aptos.Chain{Selector: aptosSel, Client: nil}, - suiSel: chainsui.Chain{ - ChainMetadata: chainsui.ChainMetadata{Selector: suiSel}, - Client: nil, - Signer: suiSigner, - }, - tonSel: ton.Chain{ChainMetadata: ton.ChainMetadata{Selector: tonSel}, Client: nil}, + evmSel: evm.Chain{Selector: evmSel, Client: evmClient, DeployerKey: evmSigner}, + solSel: solana.Chain{Selector: solSel, Client: solClient, DeployerKey: solSigner}, + aptosSel: aptos.Chain{Selector: aptosSel, Client: aptosClient, DeployerSigner: aptosSigner}, + suiSel: chainsui.Chain{ChainMetadata: chainsui.ChainMetadata{Selector: suiSel}, Client: suiClient, Signer: suiSigner}, + tonSel: ton.Chain{ChainMetadata: ton.ChainMetadata{Selector: tonSel}, Client: tonClient, Wallet: tonSigner}, stellarSel: stellar.Chain{ChainMetadata: stellar.ChainMetadata{Selector: stellarSel}, Client: nil}, cantonSel: chaincanton.Chain{ChainMetadata: chaincanton.ChainMetadata{Selector: cantonSel}, Participants: nil}, }) @@ -82,26 +110,45 @@ func TestChainAccess_SelectorsAndLookups(t *testing.T) { a := Wrap(chains) require.Equal(t, chains.ListChainSelectors(), a.Selectors()) - gotEVM, ok := a.EVMClient(evmSel) + gotEVMClient, ok := a.EVMClient(evmSel) require.True(t, ok) - require.Equal(t, evmOnchain, gotEVM) + require.Equal(t, evmClient, gotEVMClient) - gotSol, ok := a.SolanaClient(solSel) + gotEVMSigner, ok := a.EVMSigner(evmSel) require.True(t, ok) - require.Equal(t, solClient, gotSol) + require.Equal(t, evmSigner, gotEVMSigner) - gotAptos, ok := a.AptosClient(aptosSel) + gotSolClient, ok := a.SolanaClient(solSel) require.True(t, ok) - require.Nil(t, gotAptos) + require.Equal(t, solClient, gotSolClient) - gotSuiClient, gotSuiSigner, ok := a.SuiClient(suiSel) + gotSolSigner, ok := a.SolanaSigner(solSel) + require.True(t, ok) + require.Equal(t, solSigner, gotSolSigner) + + gotAptosClient, ok := a.AptosClient(aptosSel) + require.True(t, ok) + require.Equal(t, aptosClient, gotAptosClient) + + gotAptosSigner, ok := a.AptosSigner(aptosSel) + require.True(t, ok) + require.Equal(t, aptosSigner, gotAptosSigner) + + gotSuiClient, ok := a.SuiClient(suiSel) + require.True(t, ok) + require.Equal(t, suiClient, gotSuiClient) + + gotSuiSigner, ok := a.SuiSigner(suiSel) require.True(t, ok) - require.Nil(t, gotSuiClient) require.Equal(t, suiSigner, gotSuiSigner) - gotTon, ok := a.TonClient(tonSel) + gotTonClient, ok := a.TonClient(tonSel) + require.True(t, ok) + require.Equal(t, tonClient, gotTonClient) + + gotTonSigner, ok := a.TonSigner(tonSel) require.True(t, ok) - require.Nil(t, gotTon) + require.Equal(t, tonSigner, gotTonSigner) gotStellar, ok := a.StellarClient(stellarSel) require.True(t, ok) diff --git a/chain/sui/mocks/i_sui_api.go b/chain/sui/mocks/i_sui_api.go new file mode 100644 index 000000000..09273857f --- /dev/null +++ b/chain/sui/mocks/i_sui_api.go @@ -0,0 +1,3860 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify + +package mocks + +import ( + "context" + + "github.com/block-vision/sui-go-sdk/models" + mock "github.com/stretchr/testify/mock" +) + +// NewMockISuiAPI creates a new instance of MockISuiAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockISuiAPI(t interface { + mock.TestingT + Cleanup(func()) +}) *MockISuiAPI { + mock := &MockISuiAPI{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + +// MockISuiAPI is an autogenerated mock type for the ISuiAPI type +type MockISuiAPI struct { + mock.Mock +} + +type MockISuiAPI_Expecter struct { + mock *mock.Mock +} + +func (_m *MockISuiAPI) EXPECT() *MockISuiAPI_Expecter { + return &MockISuiAPI_Expecter{mock: &_m.Mock} +} + +// BatchTransaction provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) BatchTransaction(ctx context.Context, req models.BatchTransactionRequest) (models.BatchTransactionResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for BatchTransaction") + } + + var r0 models.BatchTransactionResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.BatchTransactionRequest) (models.BatchTransactionResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.BatchTransactionRequest) models.BatchTransactionResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.BatchTransactionResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.BatchTransactionRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_BatchTransaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchTransaction' +type MockISuiAPI_BatchTransaction_Call struct { + *mock.Call +} + +// BatchTransaction is a helper method to define mock.On call +// - ctx context.Context +// - req models.BatchTransactionRequest +func (_e *MockISuiAPI_Expecter) BatchTransaction(ctx interface{}, req interface{}) *MockISuiAPI_BatchTransaction_Call { + return &MockISuiAPI_BatchTransaction_Call{Call: _e.mock.On("BatchTransaction", ctx, req)} +} + +func (_c *MockISuiAPI_BatchTransaction_Call) Run(run func(ctx context.Context, req models.BatchTransactionRequest)) *MockISuiAPI_BatchTransaction_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.BatchTransactionRequest + if args[1] != nil { + arg1 = args[1].(models.BatchTransactionRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_BatchTransaction_Call) Return(batchTransactionResponse models.BatchTransactionResponse, err error) *MockISuiAPI_BatchTransaction_Call { + _c.Call.Return(batchTransactionResponse, err) + return _c +} + +func (_c *MockISuiAPI_BatchTransaction_Call) RunAndReturn(run func(ctx context.Context, req models.BatchTransactionRequest) (models.BatchTransactionResponse, error)) *MockISuiAPI_BatchTransaction_Call { + _c.Call.Return(run) + return _c +} + +// MergeCoins provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) MergeCoins(ctx context.Context, req models.MergeCoinsRequest) (models.TxnMetaData, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for MergeCoins") + } + + var r0 models.TxnMetaData + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.MergeCoinsRequest) (models.TxnMetaData, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.MergeCoinsRequest) models.TxnMetaData); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.MergeCoinsRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_MergeCoins_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MergeCoins' +type MockISuiAPI_MergeCoins_Call struct { + *mock.Call +} + +// MergeCoins is a helper method to define mock.On call +// - ctx context.Context +// - req models.MergeCoinsRequest +func (_e *MockISuiAPI_Expecter) MergeCoins(ctx interface{}, req interface{}) *MockISuiAPI_MergeCoins_Call { + return &MockISuiAPI_MergeCoins_Call{Call: _e.mock.On("MergeCoins", ctx, req)} +} + +func (_c *MockISuiAPI_MergeCoins_Call) Run(run func(ctx context.Context, req models.MergeCoinsRequest)) *MockISuiAPI_MergeCoins_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.MergeCoinsRequest + if args[1] != nil { + arg1 = args[1].(models.MergeCoinsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_MergeCoins_Call) Return(txnMetaData models.TxnMetaData, err error) *MockISuiAPI_MergeCoins_Call { + _c.Call.Return(txnMetaData, err) + return _c +} + +func (_c *MockISuiAPI_MergeCoins_Call) RunAndReturn(run func(ctx context.Context, req models.MergeCoinsRequest) (models.TxnMetaData, error)) *MockISuiAPI_MergeCoins_Call { + _c.Call.Return(run) + return _c +} + +// MoveCall provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) MoveCall(ctx context.Context, req models.MoveCallRequest) (models.TxnMetaData, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for MoveCall") + } + + var r0 models.TxnMetaData + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.MoveCallRequest) (models.TxnMetaData, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.MoveCallRequest) models.TxnMetaData); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.MoveCallRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_MoveCall_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MoveCall' +type MockISuiAPI_MoveCall_Call struct { + *mock.Call +} + +// MoveCall is a helper method to define mock.On call +// - ctx context.Context +// - req models.MoveCallRequest +func (_e *MockISuiAPI_Expecter) MoveCall(ctx interface{}, req interface{}) *MockISuiAPI_MoveCall_Call { + return &MockISuiAPI_MoveCall_Call{Call: _e.mock.On("MoveCall", ctx, req)} +} + +func (_c *MockISuiAPI_MoveCall_Call) Run(run func(ctx context.Context, req models.MoveCallRequest)) *MockISuiAPI_MoveCall_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.MoveCallRequest + if args[1] != nil { + arg1 = args[1].(models.MoveCallRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_MoveCall_Call) Return(txnMetaData models.TxnMetaData, err error) *MockISuiAPI_MoveCall_Call { + _c.Call.Return(txnMetaData, err) + return _c +} + +func (_c *MockISuiAPI_MoveCall_Call) RunAndReturn(run func(ctx context.Context, req models.MoveCallRequest) (models.TxnMetaData, error)) *MockISuiAPI_MoveCall_Call { + _c.Call.Return(run) + return _c +} + +// Pay provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) Pay(ctx context.Context, req models.PayRequest) (models.TxnMetaData, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for Pay") + } + + var r0 models.TxnMetaData + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.PayRequest) (models.TxnMetaData, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.PayRequest) models.TxnMetaData); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.PayRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_Pay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pay' +type MockISuiAPI_Pay_Call struct { + *mock.Call +} + +// Pay is a helper method to define mock.On call +// - ctx context.Context +// - req models.PayRequest +func (_e *MockISuiAPI_Expecter) Pay(ctx interface{}, req interface{}) *MockISuiAPI_Pay_Call { + return &MockISuiAPI_Pay_Call{Call: _e.mock.On("Pay", ctx, req)} +} + +func (_c *MockISuiAPI_Pay_Call) Run(run func(ctx context.Context, req models.PayRequest)) *MockISuiAPI_Pay_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.PayRequest + if args[1] != nil { + arg1 = args[1].(models.PayRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_Pay_Call) Return(txnMetaData models.TxnMetaData, err error) *MockISuiAPI_Pay_Call { + _c.Call.Return(txnMetaData, err) + return _c +} + +func (_c *MockISuiAPI_Pay_Call) RunAndReturn(run func(ctx context.Context, req models.PayRequest) (models.TxnMetaData, error)) *MockISuiAPI_Pay_Call { + _c.Call.Return(run) + return _c +} + +// PayAllSui provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) PayAllSui(ctx context.Context, req models.PayAllSuiRequest) (models.TxnMetaData, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for PayAllSui") + } + + var r0 models.TxnMetaData + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.PayAllSuiRequest) (models.TxnMetaData, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.PayAllSuiRequest) models.TxnMetaData); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.PayAllSuiRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_PayAllSui_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PayAllSui' +type MockISuiAPI_PayAllSui_Call struct { + *mock.Call +} + +// PayAllSui is a helper method to define mock.On call +// - ctx context.Context +// - req models.PayAllSuiRequest +func (_e *MockISuiAPI_Expecter) PayAllSui(ctx interface{}, req interface{}) *MockISuiAPI_PayAllSui_Call { + return &MockISuiAPI_PayAllSui_Call{Call: _e.mock.On("PayAllSui", ctx, req)} +} + +func (_c *MockISuiAPI_PayAllSui_Call) Run(run func(ctx context.Context, req models.PayAllSuiRequest)) *MockISuiAPI_PayAllSui_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.PayAllSuiRequest + if args[1] != nil { + arg1 = args[1].(models.PayAllSuiRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_PayAllSui_Call) Return(txnMetaData models.TxnMetaData, err error) *MockISuiAPI_PayAllSui_Call { + _c.Call.Return(txnMetaData, err) + return _c +} + +func (_c *MockISuiAPI_PayAllSui_Call) RunAndReturn(run func(ctx context.Context, req models.PayAllSuiRequest) (models.TxnMetaData, error)) *MockISuiAPI_PayAllSui_Call { + _c.Call.Return(run) + return _c +} + +// PaySui provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) PaySui(ctx context.Context, req models.PaySuiRequest) (models.TxnMetaData, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for PaySui") + } + + var r0 models.TxnMetaData + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.PaySuiRequest) (models.TxnMetaData, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.PaySuiRequest) models.TxnMetaData); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.PaySuiRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_PaySui_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PaySui' +type MockISuiAPI_PaySui_Call struct { + *mock.Call +} + +// PaySui is a helper method to define mock.On call +// - ctx context.Context +// - req models.PaySuiRequest +func (_e *MockISuiAPI_Expecter) PaySui(ctx interface{}, req interface{}) *MockISuiAPI_PaySui_Call { + return &MockISuiAPI_PaySui_Call{Call: _e.mock.On("PaySui", ctx, req)} +} + +func (_c *MockISuiAPI_PaySui_Call) Run(run func(ctx context.Context, req models.PaySuiRequest)) *MockISuiAPI_PaySui_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.PaySuiRequest + if args[1] != nil { + arg1 = args[1].(models.PaySuiRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_PaySui_Call) Return(txnMetaData models.TxnMetaData, err error) *MockISuiAPI_PaySui_Call { + _c.Call.Return(txnMetaData, err) + return _c +} + +func (_c *MockISuiAPI_PaySui_Call) RunAndReturn(run func(ctx context.Context, req models.PaySuiRequest) (models.TxnMetaData, error)) *MockISuiAPI_PaySui_Call { + _c.Call.Return(run) + return _c +} + +// Publish provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) Publish(ctx context.Context, req models.PublishRequest) (models.TxnMetaData, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for Publish") + } + + var r0 models.TxnMetaData + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.PublishRequest) (models.TxnMetaData, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.PublishRequest) models.TxnMetaData); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.PublishRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_Publish_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Publish' +type MockISuiAPI_Publish_Call struct { + *mock.Call +} + +// Publish is a helper method to define mock.On call +// - ctx context.Context +// - req models.PublishRequest +func (_e *MockISuiAPI_Expecter) Publish(ctx interface{}, req interface{}) *MockISuiAPI_Publish_Call { + return &MockISuiAPI_Publish_Call{Call: _e.mock.On("Publish", ctx, req)} +} + +func (_c *MockISuiAPI_Publish_Call) Run(run func(ctx context.Context, req models.PublishRequest)) *MockISuiAPI_Publish_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.PublishRequest + if args[1] != nil { + arg1 = args[1].(models.PublishRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_Publish_Call) Return(txnMetaData models.TxnMetaData, err error) *MockISuiAPI_Publish_Call { + _c.Call.Return(txnMetaData, err) + return _c +} + +func (_c *MockISuiAPI_Publish_Call) RunAndReturn(run func(ctx context.Context, req models.PublishRequest) (models.TxnMetaData, error)) *MockISuiAPI_Publish_Call { + _c.Call.Return(run) + return _c +} + +// RequestAddStake provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) RequestAddStake(ctx context.Context, req models.AddStakeRequest) (models.TxnMetaData, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for RequestAddStake") + } + + var r0 models.TxnMetaData + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.AddStakeRequest) (models.TxnMetaData, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.AddStakeRequest) models.TxnMetaData); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.AddStakeRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_RequestAddStake_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestAddStake' +type MockISuiAPI_RequestAddStake_Call struct { + *mock.Call +} + +// RequestAddStake is a helper method to define mock.On call +// - ctx context.Context +// - req models.AddStakeRequest +func (_e *MockISuiAPI_Expecter) RequestAddStake(ctx interface{}, req interface{}) *MockISuiAPI_RequestAddStake_Call { + return &MockISuiAPI_RequestAddStake_Call{Call: _e.mock.On("RequestAddStake", ctx, req)} +} + +func (_c *MockISuiAPI_RequestAddStake_Call) Run(run func(ctx context.Context, req models.AddStakeRequest)) *MockISuiAPI_RequestAddStake_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.AddStakeRequest + if args[1] != nil { + arg1 = args[1].(models.AddStakeRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_RequestAddStake_Call) Return(txnMetaData models.TxnMetaData, err error) *MockISuiAPI_RequestAddStake_Call { + _c.Call.Return(txnMetaData, err) + return _c +} + +func (_c *MockISuiAPI_RequestAddStake_Call) RunAndReturn(run func(ctx context.Context, req models.AddStakeRequest) (models.TxnMetaData, error)) *MockISuiAPI_RequestAddStake_Call { + _c.Call.Return(run) + return _c +} + +// RequestWithdrawStake provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) RequestWithdrawStake(ctx context.Context, req models.WithdrawStakeRequest) (models.TxnMetaData, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for RequestWithdrawStake") + } + + var r0 models.TxnMetaData + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.WithdrawStakeRequest) (models.TxnMetaData, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.WithdrawStakeRequest) models.TxnMetaData); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.WithdrawStakeRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_RequestWithdrawStake_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestWithdrawStake' +type MockISuiAPI_RequestWithdrawStake_Call struct { + *mock.Call +} + +// RequestWithdrawStake is a helper method to define mock.On call +// - ctx context.Context +// - req models.WithdrawStakeRequest +func (_e *MockISuiAPI_Expecter) RequestWithdrawStake(ctx interface{}, req interface{}) *MockISuiAPI_RequestWithdrawStake_Call { + return &MockISuiAPI_RequestWithdrawStake_Call{Call: _e.mock.On("RequestWithdrawStake", ctx, req)} +} + +func (_c *MockISuiAPI_RequestWithdrawStake_Call) Run(run func(ctx context.Context, req models.WithdrawStakeRequest)) *MockISuiAPI_RequestWithdrawStake_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.WithdrawStakeRequest + if args[1] != nil { + arg1 = args[1].(models.WithdrawStakeRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_RequestWithdrawStake_Call) Return(txnMetaData models.TxnMetaData, err error) *MockISuiAPI_RequestWithdrawStake_Call { + _c.Call.Return(txnMetaData, err) + return _c +} + +func (_c *MockISuiAPI_RequestWithdrawStake_Call) RunAndReturn(run func(ctx context.Context, req models.WithdrawStakeRequest) (models.TxnMetaData, error)) *MockISuiAPI_RequestWithdrawStake_Call { + _c.Call.Return(run) + return _c +} + +// SignAndExecuteTransactionBlock provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SignAndExecuteTransactionBlock(ctx context.Context, req models.SignAndExecuteTransactionBlockRequest) (models.SuiTransactionBlockResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SignAndExecuteTransactionBlock") + } + + var r0 models.SuiTransactionBlockResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SignAndExecuteTransactionBlockRequest) (models.SuiTransactionBlockResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SignAndExecuteTransactionBlockRequest) models.SuiTransactionBlockResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiTransactionBlockResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SignAndExecuteTransactionBlockRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SignAndExecuteTransactionBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignAndExecuteTransactionBlock' +type MockISuiAPI_SignAndExecuteTransactionBlock_Call struct { + *mock.Call +} + +// SignAndExecuteTransactionBlock is a helper method to define mock.On call +// - ctx context.Context +// - req models.SignAndExecuteTransactionBlockRequest +func (_e *MockISuiAPI_Expecter) SignAndExecuteTransactionBlock(ctx interface{}, req interface{}) *MockISuiAPI_SignAndExecuteTransactionBlock_Call { + return &MockISuiAPI_SignAndExecuteTransactionBlock_Call{Call: _e.mock.On("SignAndExecuteTransactionBlock", ctx, req)} +} + +func (_c *MockISuiAPI_SignAndExecuteTransactionBlock_Call) Run(run func(ctx context.Context, req models.SignAndExecuteTransactionBlockRequest)) *MockISuiAPI_SignAndExecuteTransactionBlock_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SignAndExecuteTransactionBlockRequest + if args[1] != nil { + arg1 = args[1].(models.SignAndExecuteTransactionBlockRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SignAndExecuteTransactionBlock_Call) Return(suiTransactionBlockResponse models.SuiTransactionBlockResponse, err error) *MockISuiAPI_SignAndExecuteTransactionBlock_Call { + _c.Call.Return(suiTransactionBlockResponse, err) + return _c +} + +func (_c *MockISuiAPI_SignAndExecuteTransactionBlock_Call) RunAndReturn(run func(ctx context.Context, req models.SignAndExecuteTransactionBlockRequest) (models.SuiTransactionBlockResponse, error)) *MockISuiAPI_SignAndExecuteTransactionBlock_Call { + _c.Call.Return(run) + return _c +} + +// SplitCoin provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SplitCoin(ctx context.Context, req models.SplitCoinRequest) (models.TxnMetaData, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SplitCoin") + } + + var r0 models.TxnMetaData + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SplitCoinRequest) (models.TxnMetaData, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SplitCoinRequest) models.TxnMetaData); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SplitCoinRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SplitCoin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SplitCoin' +type MockISuiAPI_SplitCoin_Call struct { + *mock.Call +} + +// SplitCoin is a helper method to define mock.On call +// - ctx context.Context +// - req models.SplitCoinRequest +func (_e *MockISuiAPI_Expecter) SplitCoin(ctx interface{}, req interface{}) *MockISuiAPI_SplitCoin_Call { + return &MockISuiAPI_SplitCoin_Call{Call: _e.mock.On("SplitCoin", ctx, req)} +} + +func (_c *MockISuiAPI_SplitCoin_Call) Run(run func(ctx context.Context, req models.SplitCoinRequest)) *MockISuiAPI_SplitCoin_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SplitCoinRequest + if args[1] != nil { + arg1 = args[1].(models.SplitCoinRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SplitCoin_Call) Return(txnMetaData models.TxnMetaData, err error) *MockISuiAPI_SplitCoin_Call { + _c.Call.Return(txnMetaData, err) + return _c +} + +func (_c *MockISuiAPI_SplitCoin_Call) RunAndReturn(run func(ctx context.Context, req models.SplitCoinRequest) (models.TxnMetaData, error)) *MockISuiAPI_SplitCoin_Call { + _c.Call.Return(run) + return _c +} + +// SplitCoinEqual provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SplitCoinEqual(ctx context.Context, req models.SplitCoinEqualRequest) (models.TxnMetaData, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SplitCoinEqual") + } + + var r0 models.TxnMetaData + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SplitCoinEqualRequest) (models.TxnMetaData, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SplitCoinEqualRequest) models.TxnMetaData); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SplitCoinEqualRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SplitCoinEqual_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SplitCoinEqual' +type MockISuiAPI_SplitCoinEqual_Call struct { + *mock.Call +} + +// SplitCoinEqual is a helper method to define mock.On call +// - ctx context.Context +// - req models.SplitCoinEqualRequest +func (_e *MockISuiAPI_Expecter) SplitCoinEqual(ctx interface{}, req interface{}) *MockISuiAPI_SplitCoinEqual_Call { + return &MockISuiAPI_SplitCoinEqual_Call{Call: _e.mock.On("SplitCoinEqual", ctx, req)} +} + +func (_c *MockISuiAPI_SplitCoinEqual_Call) Run(run func(ctx context.Context, req models.SplitCoinEqualRequest)) *MockISuiAPI_SplitCoinEqual_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SplitCoinEqualRequest + if args[1] != nil { + arg1 = args[1].(models.SplitCoinEqualRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SplitCoinEqual_Call) Return(txnMetaData models.TxnMetaData, err error) *MockISuiAPI_SplitCoinEqual_Call { + _c.Call.Return(txnMetaData, err) + return _c +} + +func (_c *MockISuiAPI_SplitCoinEqual_Call) RunAndReturn(run func(ctx context.Context, req models.SplitCoinEqualRequest) (models.TxnMetaData, error)) *MockISuiAPI_SplitCoinEqual_Call { + _c.Call.Return(run) + return _c +} + +// SuiCall provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiCall(ctx context.Context, method string, params ...interface{}) (interface{}, error) { + var tmpRet mock.Arguments + if len(params) > 0 { + tmpRet = _mock.Called(ctx, method, params) + } else { + tmpRet = _mock.Called(ctx, method) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for SuiCall") + } + + var r0 interface{} + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string, ...interface{}) (interface{}, error)); ok { + return returnFunc(ctx, method, params...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, string, ...interface{}) interface{}); ok { + r0 = returnFunc(ctx, method, params...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interface{}) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, string, ...interface{}) error); ok { + r1 = returnFunc(ctx, method, params...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiCall_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiCall' +type MockISuiAPI_SuiCall_Call struct { + *mock.Call +} + +// SuiCall is a helper method to define mock.On call +// - ctx context.Context +// - method string +// - params ...interface{} +func (_e *MockISuiAPI_Expecter) SuiCall(ctx interface{}, method interface{}, params ...interface{}) *MockISuiAPI_SuiCall_Call { + return &MockISuiAPI_SuiCall_Call{Call: _e.mock.On("SuiCall", + append([]interface{}{ctx, method}, params...)...)} +} + +func (_c *MockISuiAPI_SuiCall_Call) Run(run func(ctx context.Context, method string, params ...interface{})) *MockISuiAPI_SuiCall_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 []interface{} + var variadicArgs []interface{} + if len(args) > 2 { + variadicArgs = args[2].([]interface{}) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiCall_Call) Return(ifaceVal interface{}, err error) *MockISuiAPI_SuiCall_Call { + _c.Call.Return(ifaceVal, err) + return _c +} + +func (_c *MockISuiAPI_SuiCall_Call) RunAndReturn(run func(ctx context.Context, method string, params ...interface{}) (interface{}, error)) *MockISuiAPI_SuiCall_Call { + _c.Call.Return(run) + return _c +} + +// SuiDevInspectTransactionBlock provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiDevInspectTransactionBlock(ctx context.Context, req models.SuiDevInspectTransactionBlockRequest) (models.SuiTransactionBlockResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiDevInspectTransactionBlock") + } + + var r0 models.SuiTransactionBlockResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiDevInspectTransactionBlockRequest) (models.SuiTransactionBlockResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiDevInspectTransactionBlockRequest) models.SuiTransactionBlockResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiTransactionBlockResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiDevInspectTransactionBlockRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiDevInspectTransactionBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiDevInspectTransactionBlock' +type MockISuiAPI_SuiDevInspectTransactionBlock_Call struct { + *mock.Call +} + +// SuiDevInspectTransactionBlock is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiDevInspectTransactionBlockRequest +func (_e *MockISuiAPI_Expecter) SuiDevInspectTransactionBlock(ctx interface{}, req interface{}) *MockISuiAPI_SuiDevInspectTransactionBlock_Call { + return &MockISuiAPI_SuiDevInspectTransactionBlock_Call{Call: _e.mock.On("SuiDevInspectTransactionBlock", ctx, req)} +} + +func (_c *MockISuiAPI_SuiDevInspectTransactionBlock_Call) Run(run func(ctx context.Context, req models.SuiDevInspectTransactionBlockRequest)) *MockISuiAPI_SuiDevInspectTransactionBlock_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiDevInspectTransactionBlockRequest + if args[1] != nil { + arg1 = args[1].(models.SuiDevInspectTransactionBlockRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiDevInspectTransactionBlock_Call) Return(suiTransactionBlockResponse models.SuiTransactionBlockResponse, err error) *MockISuiAPI_SuiDevInspectTransactionBlock_Call { + _c.Call.Return(suiTransactionBlockResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiDevInspectTransactionBlock_Call) RunAndReturn(run func(ctx context.Context, req models.SuiDevInspectTransactionBlockRequest) (models.SuiTransactionBlockResponse, error)) *MockISuiAPI_SuiDevInspectTransactionBlock_Call { + _c.Call.Return(run) + return _c +} + +// SuiDryRunTransactionBlock provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiDryRunTransactionBlock(ctx context.Context, req models.SuiDryRunTransactionBlockRequest) (models.SuiTransactionBlockResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiDryRunTransactionBlock") + } + + var r0 models.SuiTransactionBlockResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiDryRunTransactionBlockRequest) (models.SuiTransactionBlockResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiDryRunTransactionBlockRequest) models.SuiTransactionBlockResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiTransactionBlockResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiDryRunTransactionBlockRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiDryRunTransactionBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiDryRunTransactionBlock' +type MockISuiAPI_SuiDryRunTransactionBlock_Call struct { + *mock.Call +} + +// SuiDryRunTransactionBlock is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiDryRunTransactionBlockRequest +func (_e *MockISuiAPI_Expecter) SuiDryRunTransactionBlock(ctx interface{}, req interface{}) *MockISuiAPI_SuiDryRunTransactionBlock_Call { + return &MockISuiAPI_SuiDryRunTransactionBlock_Call{Call: _e.mock.On("SuiDryRunTransactionBlock", ctx, req)} +} + +func (_c *MockISuiAPI_SuiDryRunTransactionBlock_Call) Run(run func(ctx context.Context, req models.SuiDryRunTransactionBlockRequest)) *MockISuiAPI_SuiDryRunTransactionBlock_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiDryRunTransactionBlockRequest + if args[1] != nil { + arg1 = args[1].(models.SuiDryRunTransactionBlockRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiDryRunTransactionBlock_Call) Return(suiTransactionBlockResponse models.SuiTransactionBlockResponse, err error) *MockISuiAPI_SuiDryRunTransactionBlock_Call { + _c.Call.Return(suiTransactionBlockResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiDryRunTransactionBlock_Call) RunAndReturn(run func(ctx context.Context, req models.SuiDryRunTransactionBlockRequest) (models.SuiTransactionBlockResponse, error)) *MockISuiAPI_SuiDryRunTransactionBlock_Call { + _c.Call.Return(run) + return _c +} + +// SuiExecuteTransactionBlock provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiExecuteTransactionBlock(ctx context.Context, req models.SuiExecuteTransactionBlockRequest) (models.SuiTransactionBlockResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiExecuteTransactionBlock") + } + + var r0 models.SuiTransactionBlockResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiExecuteTransactionBlockRequest) (models.SuiTransactionBlockResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiExecuteTransactionBlockRequest) models.SuiTransactionBlockResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiTransactionBlockResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiExecuteTransactionBlockRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiExecuteTransactionBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiExecuteTransactionBlock' +type MockISuiAPI_SuiExecuteTransactionBlock_Call struct { + *mock.Call +} + +// SuiExecuteTransactionBlock is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiExecuteTransactionBlockRequest +func (_e *MockISuiAPI_Expecter) SuiExecuteTransactionBlock(ctx interface{}, req interface{}) *MockISuiAPI_SuiExecuteTransactionBlock_Call { + return &MockISuiAPI_SuiExecuteTransactionBlock_Call{Call: _e.mock.On("SuiExecuteTransactionBlock", ctx, req)} +} + +func (_c *MockISuiAPI_SuiExecuteTransactionBlock_Call) Run(run func(ctx context.Context, req models.SuiExecuteTransactionBlockRequest)) *MockISuiAPI_SuiExecuteTransactionBlock_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiExecuteTransactionBlockRequest + if args[1] != nil { + arg1 = args[1].(models.SuiExecuteTransactionBlockRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiExecuteTransactionBlock_Call) Return(suiTransactionBlockResponse models.SuiTransactionBlockResponse, err error) *MockISuiAPI_SuiExecuteTransactionBlock_Call { + _c.Call.Return(suiTransactionBlockResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiExecuteTransactionBlock_Call) RunAndReturn(run func(ctx context.Context, req models.SuiExecuteTransactionBlockRequest) (models.SuiTransactionBlockResponse, error)) *MockISuiAPI_SuiExecuteTransactionBlock_Call { + _c.Call.Return(run) + return _c +} + +// SuiGetChainIdentifier provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiGetChainIdentifier(ctx context.Context) (string, error) { + ret := _mock.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for SuiGetChainIdentifier") + } + + var r0 string + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context) (string, error)); ok { + return returnFunc(ctx) + } + if returnFunc, ok := ret.Get(0).(func(context.Context) string); ok { + r0 = returnFunc(ctx) + } else { + r0 = ret.Get(0).(string) + } + if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = returnFunc(ctx) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiGetChainIdentifier_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiGetChainIdentifier' +type MockISuiAPI_SuiGetChainIdentifier_Call struct { + *mock.Call +} + +// SuiGetChainIdentifier is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockISuiAPI_Expecter) SuiGetChainIdentifier(ctx interface{}) *MockISuiAPI_SuiGetChainIdentifier_Call { + return &MockISuiAPI_SuiGetChainIdentifier_Call{Call: _e.mock.On("SuiGetChainIdentifier", ctx)} +} + +func (_c *MockISuiAPI_SuiGetChainIdentifier_Call) Run(run func(ctx context.Context)) *MockISuiAPI_SuiGetChainIdentifier_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiGetChainIdentifier_Call) Return(s string, err error) *MockISuiAPI_SuiGetChainIdentifier_Call { + _c.Call.Return(s, err) + return _c +} + +func (_c *MockISuiAPI_SuiGetChainIdentifier_Call) RunAndReturn(run func(ctx context.Context) (string, error)) *MockISuiAPI_SuiGetChainIdentifier_Call { + _c.Call.Return(run) + return _c +} + +// SuiGetCheckpoint provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiGetCheckpoint(ctx context.Context, req models.SuiGetCheckpointRequest) (models.CheckpointResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetCheckpoint") + } + + var r0 models.CheckpointResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiGetCheckpointRequest) (models.CheckpointResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiGetCheckpointRequest) models.CheckpointResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.CheckpointResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiGetCheckpointRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiGetCheckpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiGetCheckpoint' +type MockISuiAPI_SuiGetCheckpoint_Call struct { + *mock.Call +} + +// SuiGetCheckpoint is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiGetCheckpointRequest +func (_e *MockISuiAPI_Expecter) SuiGetCheckpoint(ctx interface{}, req interface{}) *MockISuiAPI_SuiGetCheckpoint_Call { + return &MockISuiAPI_SuiGetCheckpoint_Call{Call: _e.mock.On("SuiGetCheckpoint", ctx, req)} +} + +func (_c *MockISuiAPI_SuiGetCheckpoint_Call) Run(run func(ctx context.Context, req models.SuiGetCheckpointRequest)) *MockISuiAPI_SuiGetCheckpoint_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiGetCheckpointRequest + if args[1] != nil { + arg1 = args[1].(models.SuiGetCheckpointRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiGetCheckpoint_Call) Return(checkpointResponse models.CheckpointResponse, err error) *MockISuiAPI_SuiGetCheckpoint_Call { + _c.Call.Return(checkpointResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiGetCheckpoint_Call) RunAndReturn(run func(ctx context.Context, req models.SuiGetCheckpointRequest) (models.CheckpointResponse, error)) *MockISuiAPI_SuiGetCheckpoint_Call { + _c.Call.Return(run) + return _c +} + +// SuiGetCheckpoints provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiGetCheckpoints(ctx context.Context, req models.SuiGetCheckpointsRequest) (models.PaginatedCheckpointsResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetCheckpoints") + } + + var r0 models.PaginatedCheckpointsResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiGetCheckpointsRequest) (models.PaginatedCheckpointsResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiGetCheckpointsRequest) models.PaginatedCheckpointsResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.PaginatedCheckpointsResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiGetCheckpointsRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiGetCheckpoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiGetCheckpoints' +type MockISuiAPI_SuiGetCheckpoints_Call struct { + *mock.Call +} + +// SuiGetCheckpoints is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiGetCheckpointsRequest +func (_e *MockISuiAPI_Expecter) SuiGetCheckpoints(ctx interface{}, req interface{}) *MockISuiAPI_SuiGetCheckpoints_Call { + return &MockISuiAPI_SuiGetCheckpoints_Call{Call: _e.mock.On("SuiGetCheckpoints", ctx, req)} +} + +func (_c *MockISuiAPI_SuiGetCheckpoints_Call) Run(run func(ctx context.Context, req models.SuiGetCheckpointsRequest)) *MockISuiAPI_SuiGetCheckpoints_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiGetCheckpointsRequest + if args[1] != nil { + arg1 = args[1].(models.SuiGetCheckpointsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiGetCheckpoints_Call) Return(paginatedCheckpointsResponse models.PaginatedCheckpointsResponse, err error) *MockISuiAPI_SuiGetCheckpoints_Call { + _c.Call.Return(paginatedCheckpointsResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiGetCheckpoints_Call) RunAndReturn(run func(ctx context.Context, req models.SuiGetCheckpointsRequest) (models.PaginatedCheckpointsResponse, error)) *MockISuiAPI_SuiGetCheckpoints_Call { + _c.Call.Return(run) + return _c +} + +// SuiGetEvents provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiGetEvents(ctx context.Context, req models.SuiGetEventsRequest) (models.GetEventsResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetEvents") + } + + var r0 models.GetEventsResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiGetEventsRequest) (models.GetEventsResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiGetEventsRequest) models.GetEventsResponse); ok { + r0 = returnFunc(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(models.GetEventsResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiGetEventsRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiGetEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiGetEvents' +type MockISuiAPI_SuiGetEvents_Call struct { + *mock.Call +} + +// SuiGetEvents is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiGetEventsRequest +func (_e *MockISuiAPI_Expecter) SuiGetEvents(ctx interface{}, req interface{}) *MockISuiAPI_SuiGetEvents_Call { + return &MockISuiAPI_SuiGetEvents_Call{Call: _e.mock.On("SuiGetEvents", ctx, req)} +} + +func (_c *MockISuiAPI_SuiGetEvents_Call) Run(run func(ctx context.Context, req models.SuiGetEventsRequest)) *MockISuiAPI_SuiGetEvents_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiGetEventsRequest + if args[1] != nil { + arg1 = args[1].(models.SuiGetEventsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiGetEvents_Call) Return(getEventsResponse models.GetEventsResponse, err error) *MockISuiAPI_SuiGetEvents_Call { + _c.Call.Return(getEventsResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiGetEvents_Call) RunAndReturn(run func(ctx context.Context, req models.SuiGetEventsRequest) (models.GetEventsResponse, error)) *MockISuiAPI_SuiGetEvents_Call { + _c.Call.Return(run) + return _c +} + +// SuiGetLatestCheckpointSequenceNumber provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiGetLatestCheckpointSequenceNumber(ctx context.Context) (uint64, error) { + ret := _mock.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for SuiGetLatestCheckpointSequenceNumber") + } + + var r0 uint64 + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context) (uint64, error)); ok { + return returnFunc(ctx) + } + if returnFunc, ok := ret.Get(0).(func(context.Context) uint64); ok { + r0 = returnFunc(ctx) + } else { + r0 = ret.Get(0).(uint64) + } + if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = returnFunc(ctx) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiGetLatestCheckpointSequenceNumber_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiGetLatestCheckpointSequenceNumber' +type MockISuiAPI_SuiGetLatestCheckpointSequenceNumber_Call struct { + *mock.Call +} + +// SuiGetLatestCheckpointSequenceNumber is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockISuiAPI_Expecter) SuiGetLatestCheckpointSequenceNumber(ctx interface{}) *MockISuiAPI_SuiGetLatestCheckpointSequenceNumber_Call { + return &MockISuiAPI_SuiGetLatestCheckpointSequenceNumber_Call{Call: _e.mock.On("SuiGetLatestCheckpointSequenceNumber", ctx)} +} + +func (_c *MockISuiAPI_SuiGetLatestCheckpointSequenceNumber_Call) Run(run func(ctx context.Context)) *MockISuiAPI_SuiGetLatestCheckpointSequenceNumber_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiGetLatestCheckpointSequenceNumber_Call) Return(v uint64, err error) *MockISuiAPI_SuiGetLatestCheckpointSequenceNumber_Call { + _c.Call.Return(v, err) + return _c +} + +func (_c *MockISuiAPI_SuiGetLatestCheckpointSequenceNumber_Call) RunAndReturn(run func(ctx context.Context) (uint64, error)) *MockISuiAPI_SuiGetLatestCheckpointSequenceNumber_Call { + _c.Call.Return(run) + return _c +} + +// SuiGetLoadedChildObjects provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiGetLoadedChildObjects(ctx context.Context, req models.SuiGetLoadedChildObjectsRequest) (models.ChildObjectsResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetLoadedChildObjects") + } + + var r0 models.ChildObjectsResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiGetLoadedChildObjectsRequest) (models.ChildObjectsResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiGetLoadedChildObjectsRequest) models.ChildObjectsResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.ChildObjectsResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiGetLoadedChildObjectsRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiGetLoadedChildObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiGetLoadedChildObjects' +type MockISuiAPI_SuiGetLoadedChildObjects_Call struct { + *mock.Call +} + +// SuiGetLoadedChildObjects is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiGetLoadedChildObjectsRequest +func (_e *MockISuiAPI_Expecter) SuiGetLoadedChildObjects(ctx interface{}, req interface{}) *MockISuiAPI_SuiGetLoadedChildObjects_Call { + return &MockISuiAPI_SuiGetLoadedChildObjects_Call{Call: _e.mock.On("SuiGetLoadedChildObjects", ctx, req)} +} + +func (_c *MockISuiAPI_SuiGetLoadedChildObjects_Call) Run(run func(ctx context.Context, req models.SuiGetLoadedChildObjectsRequest)) *MockISuiAPI_SuiGetLoadedChildObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiGetLoadedChildObjectsRequest + if args[1] != nil { + arg1 = args[1].(models.SuiGetLoadedChildObjectsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiGetLoadedChildObjects_Call) Return(childObjectsResponse models.ChildObjectsResponse, err error) *MockISuiAPI_SuiGetLoadedChildObjects_Call { + _c.Call.Return(childObjectsResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiGetLoadedChildObjects_Call) RunAndReturn(run func(ctx context.Context, req models.SuiGetLoadedChildObjectsRequest) (models.ChildObjectsResponse, error)) *MockISuiAPI_SuiGetLoadedChildObjects_Call { + _c.Call.Return(run) + return _c +} + +// SuiGetMoveFunctionArgTypes provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiGetMoveFunctionArgTypes(ctx context.Context, req models.GetMoveFunctionArgTypesRequest) (models.GetMoveFunctionArgTypesResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetMoveFunctionArgTypes") + } + + var r0 models.GetMoveFunctionArgTypesResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.GetMoveFunctionArgTypesRequest) (models.GetMoveFunctionArgTypesResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.GetMoveFunctionArgTypesRequest) models.GetMoveFunctionArgTypesResponse); ok { + r0 = returnFunc(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(models.GetMoveFunctionArgTypesResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.GetMoveFunctionArgTypesRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiGetMoveFunctionArgTypes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiGetMoveFunctionArgTypes' +type MockISuiAPI_SuiGetMoveFunctionArgTypes_Call struct { + *mock.Call +} + +// SuiGetMoveFunctionArgTypes is a helper method to define mock.On call +// - ctx context.Context +// - req models.GetMoveFunctionArgTypesRequest +func (_e *MockISuiAPI_Expecter) SuiGetMoveFunctionArgTypes(ctx interface{}, req interface{}) *MockISuiAPI_SuiGetMoveFunctionArgTypes_Call { + return &MockISuiAPI_SuiGetMoveFunctionArgTypes_Call{Call: _e.mock.On("SuiGetMoveFunctionArgTypes", ctx, req)} +} + +func (_c *MockISuiAPI_SuiGetMoveFunctionArgTypes_Call) Run(run func(ctx context.Context, req models.GetMoveFunctionArgTypesRequest)) *MockISuiAPI_SuiGetMoveFunctionArgTypes_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.GetMoveFunctionArgTypesRequest + if args[1] != nil { + arg1 = args[1].(models.GetMoveFunctionArgTypesRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiGetMoveFunctionArgTypes_Call) Return(getMoveFunctionArgTypesResponse models.GetMoveFunctionArgTypesResponse, err error) *MockISuiAPI_SuiGetMoveFunctionArgTypes_Call { + _c.Call.Return(getMoveFunctionArgTypesResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiGetMoveFunctionArgTypes_Call) RunAndReturn(run func(ctx context.Context, req models.GetMoveFunctionArgTypesRequest) (models.GetMoveFunctionArgTypesResponse, error)) *MockISuiAPI_SuiGetMoveFunctionArgTypes_Call { + _c.Call.Return(run) + return _c +} + +// SuiGetNormalizedMoveFunction provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiGetNormalizedMoveFunction(ctx context.Context, req models.GetNormalizedMoveFunctionRequest) (models.GetNormalizedMoveFunctionResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetNormalizedMoveFunction") + } + + var r0 models.GetNormalizedMoveFunctionResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.GetNormalizedMoveFunctionRequest) (models.GetNormalizedMoveFunctionResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.GetNormalizedMoveFunctionRequest) models.GetNormalizedMoveFunctionResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.GetNormalizedMoveFunctionResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.GetNormalizedMoveFunctionRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiGetNormalizedMoveFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiGetNormalizedMoveFunction' +type MockISuiAPI_SuiGetNormalizedMoveFunction_Call struct { + *mock.Call +} + +// SuiGetNormalizedMoveFunction is a helper method to define mock.On call +// - ctx context.Context +// - req models.GetNormalizedMoveFunctionRequest +func (_e *MockISuiAPI_Expecter) SuiGetNormalizedMoveFunction(ctx interface{}, req interface{}) *MockISuiAPI_SuiGetNormalizedMoveFunction_Call { + return &MockISuiAPI_SuiGetNormalizedMoveFunction_Call{Call: _e.mock.On("SuiGetNormalizedMoveFunction", ctx, req)} +} + +func (_c *MockISuiAPI_SuiGetNormalizedMoveFunction_Call) Run(run func(ctx context.Context, req models.GetNormalizedMoveFunctionRequest)) *MockISuiAPI_SuiGetNormalizedMoveFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.GetNormalizedMoveFunctionRequest + if args[1] != nil { + arg1 = args[1].(models.GetNormalizedMoveFunctionRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiGetNormalizedMoveFunction_Call) Return(getNormalizedMoveFunctionResponse models.GetNormalizedMoveFunctionResponse, err error) *MockISuiAPI_SuiGetNormalizedMoveFunction_Call { + _c.Call.Return(getNormalizedMoveFunctionResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiGetNormalizedMoveFunction_Call) RunAndReturn(run func(ctx context.Context, req models.GetNormalizedMoveFunctionRequest) (models.GetNormalizedMoveFunctionResponse, error)) *MockISuiAPI_SuiGetNormalizedMoveFunction_Call { + _c.Call.Return(run) + return _c +} + +// SuiGetNormalizedMoveModule provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiGetNormalizedMoveModule(ctx context.Context, req models.GetNormalizedMoveModuleRequest) (models.GetNormalizedMoveModuleResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetNormalizedMoveModule") + } + + var r0 models.GetNormalizedMoveModuleResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.GetNormalizedMoveModuleRequest) (models.GetNormalizedMoveModuleResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.GetNormalizedMoveModuleRequest) models.GetNormalizedMoveModuleResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.GetNormalizedMoveModuleResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.GetNormalizedMoveModuleRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiGetNormalizedMoveModule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiGetNormalizedMoveModule' +type MockISuiAPI_SuiGetNormalizedMoveModule_Call struct { + *mock.Call +} + +// SuiGetNormalizedMoveModule is a helper method to define mock.On call +// - ctx context.Context +// - req models.GetNormalizedMoveModuleRequest +func (_e *MockISuiAPI_Expecter) SuiGetNormalizedMoveModule(ctx interface{}, req interface{}) *MockISuiAPI_SuiGetNormalizedMoveModule_Call { + return &MockISuiAPI_SuiGetNormalizedMoveModule_Call{Call: _e.mock.On("SuiGetNormalizedMoveModule", ctx, req)} +} + +func (_c *MockISuiAPI_SuiGetNormalizedMoveModule_Call) Run(run func(ctx context.Context, req models.GetNormalizedMoveModuleRequest)) *MockISuiAPI_SuiGetNormalizedMoveModule_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.GetNormalizedMoveModuleRequest + if args[1] != nil { + arg1 = args[1].(models.GetNormalizedMoveModuleRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiGetNormalizedMoveModule_Call) Return(getNormalizedMoveModuleResponse models.GetNormalizedMoveModuleResponse, err error) *MockISuiAPI_SuiGetNormalizedMoveModule_Call { + _c.Call.Return(getNormalizedMoveModuleResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiGetNormalizedMoveModule_Call) RunAndReturn(run func(ctx context.Context, req models.GetNormalizedMoveModuleRequest) (models.GetNormalizedMoveModuleResponse, error)) *MockISuiAPI_SuiGetNormalizedMoveModule_Call { + _c.Call.Return(run) + return _c +} + +// SuiGetNormalizedMoveModulesByPackage provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiGetNormalizedMoveModulesByPackage(ctx context.Context, req models.GetNormalizedMoveModulesByPackageRequest) (models.GetNormalizedMoveModulesByPackageResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetNormalizedMoveModulesByPackage") + } + + var r0 models.GetNormalizedMoveModulesByPackageResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.GetNormalizedMoveModulesByPackageRequest) (models.GetNormalizedMoveModulesByPackageResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.GetNormalizedMoveModulesByPackageRequest) models.GetNormalizedMoveModulesByPackageResponse); ok { + r0 = returnFunc(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(models.GetNormalizedMoveModulesByPackageResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.GetNormalizedMoveModulesByPackageRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiGetNormalizedMoveModulesByPackage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiGetNormalizedMoveModulesByPackage' +type MockISuiAPI_SuiGetNormalizedMoveModulesByPackage_Call struct { + *mock.Call +} + +// SuiGetNormalizedMoveModulesByPackage is a helper method to define mock.On call +// - ctx context.Context +// - req models.GetNormalizedMoveModulesByPackageRequest +func (_e *MockISuiAPI_Expecter) SuiGetNormalizedMoveModulesByPackage(ctx interface{}, req interface{}) *MockISuiAPI_SuiGetNormalizedMoveModulesByPackage_Call { + return &MockISuiAPI_SuiGetNormalizedMoveModulesByPackage_Call{Call: _e.mock.On("SuiGetNormalizedMoveModulesByPackage", ctx, req)} +} + +func (_c *MockISuiAPI_SuiGetNormalizedMoveModulesByPackage_Call) Run(run func(ctx context.Context, req models.GetNormalizedMoveModulesByPackageRequest)) *MockISuiAPI_SuiGetNormalizedMoveModulesByPackage_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.GetNormalizedMoveModulesByPackageRequest + if args[1] != nil { + arg1 = args[1].(models.GetNormalizedMoveModulesByPackageRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiGetNormalizedMoveModulesByPackage_Call) Return(getNormalizedMoveModulesByPackageResponse models.GetNormalizedMoveModulesByPackageResponse, err error) *MockISuiAPI_SuiGetNormalizedMoveModulesByPackage_Call { + _c.Call.Return(getNormalizedMoveModulesByPackageResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiGetNormalizedMoveModulesByPackage_Call) RunAndReturn(run func(ctx context.Context, req models.GetNormalizedMoveModulesByPackageRequest) (models.GetNormalizedMoveModulesByPackageResponse, error)) *MockISuiAPI_SuiGetNormalizedMoveModulesByPackage_Call { + _c.Call.Return(run) + return _c +} + +// SuiGetNormalizedMoveStruct provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiGetNormalizedMoveStruct(ctx context.Context, req models.GetNormalizedMoveStructRequest) (models.GetNormalizedMoveStructResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetNormalizedMoveStruct") + } + + var r0 models.GetNormalizedMoveStructResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.GetNormalizedMoveStructRequest) (models.GetNormalizedMoveStructResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.GetNormalizedMoveStructRequest) models.GetNormalizedMoveStructResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.GetNormalizedMoveStructResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.GetNormalizedMoveStructRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiGetNormalizedMoveStruct_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiGetNormalizedMoveStruct' +type MockISuiAPI_SuiGetNormalizedMoveStruct_Call struct { + *mock.Call +} + +// SuiGetNormalizedMoveStruct is a helper method to define mock.On call +// - ctx context.Context +// - req models.GetNormalizedMoveStructRequest +func (_e *MockISuiAPI_Expecter) SuiGetNormalizedMoveStruct(ctx interface{}, req interface{}) *MockISuiAPI_SuiGetNormalizedMoveStruct_Call { + return &MockISuiAPI_SuiGetNormalizedMoveStruct_Call{Call: _e.mock.On("SuiGetNormalizedMoveStruct", ctx, req)} +} + +func (_c *MockISuiAPI_SuiGetNormalizedMoveStruct_Call) Run(run func(ctx context.Context, req models.GetNormalizedMoveStructRequest)) *MockISuiAPI_SuiGetNormalizedMoveStruct_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.GetNormalizedMoveStructRequest + if args[1] != nil { + arg1 = args[1].(models.GetNormalizedMoveStructRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiGetNormalizedMoveStruct_Call) Return(getNormalizedMoveStructResponse models.GetNormalizedMoveStructResponse, err error) *MockISuiAPI_SuiGetNormalizedMoveStruct_Call { + _c.Call.Return(getNormalizedMoveStructResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiGetNormalizedMoveStruct_Call) RunAndReturn(run func(ctx context.Context, req models.GetNormalizedMoveStructRequest) (models.GetNormalizedMoveStructResponse, error)) *MockISuiAPI_SuiGetNormalizedMoveStruct_Call { + _c.Call.Return(run) + return _c +} + +// SuiGetObject provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiGetObject(ctx context.Context, req models.SuiGetObjectRequest) (models.SuiObjectResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetObject") + } + + var r0 models.SuiObjectResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiGetObjectRequest) (models.SuiObjectResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiGetObjectRequest) models.SuiObjectResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiObjectResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiGetObjectRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiGetObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiGetObject' +type MockISuiAPI_SuiGetObject_Call struct { + *mock.Call +} + +// SuiGetObject is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiGetObjectRequest +func (_e *MockISuiAPI_Expecter) SuiGetObject(ctx interface{}, req interface{}) *MockISuiAPI_SuiGetObject_Call { + return &MockISuiAPI_SuiGetObject_Call{Call: _e.mock.On("SuiGetObject", ctx, req)} +} + +func (_c *MockISuiAPI_SuiGetObject_Call) Run(run func(ctx context.Context, req models.SuiGetObjectRequest)) *MockISuiAPI_SuiGetObject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiGetObjectRequest + if args[1] != nil { + arg1 = args[1].(models.SuiGetObjectRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiGetObject_Call) Return(suiObjectResponse models.SuiObjectResponse, err error) *MockISuiAPI_SuiGetObject_Call { + _c.Call.Return(suiObjectResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiGetObject_Call) RunAndReturn(run func(ctx context.Context, req models.SuiGetObjectRequest) (models.SuiObjectResponse, error)) *MockISuiAPI_SuiGetObject_Call { + _c.Call.Return(run) + return _c +} + +// SuiGetProtocolConfig provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiGetProtocolConfig(ctx context.Context, req models.SuiGetProtocolConfigRequest) (models.ProtocolConfigResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetProtocolConfig") + } + + var r0 models.ProtocolConfigResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiGetProtocolConfigRequest) (models.ProtocolConfigResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiGetProtocolConfigRequest) models.ProtocolConfigResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.ProtocolConfigResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiGetProtocolConfigRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiGetProtocolConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiGetProtocolConfig' +type MockISuiAPI_SuiGetProtocolConfig_Call struct { + *mock.Call +} + +// SuiGetProtocolConfig is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiGetProtocolConfigRequest +func (_e *MockISuiAPI_Expecter) SuiGetProtocolConfig(ctx interface{}, req interface{}) *MockISuiAPI_SuiGetProtocolConfig_Call { + return &MockISuiAPI_SuiGetProtocolConfig_Call{Call: _e.mock.On("SuiGetProtocolConfig", ctx, req)} +} + +func (_c *MockISuiAPI_SuiGetProtocolConfig_Call) Run(run func(ctx context.Context, req models.SuiGetProtocolConfigRequest)) *MockISuiAPI_SuiGetProtocolConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiGetProtocolConfigRequest + if args[1] != nil { + arg1 = args[1].(models.SuiGetProtocolConfigRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiGetProtocolConfig_Call) Return(protocolConfigResponse models.ProtocolConfigResponse, err error) *MockISuiAPI_SuiGetProtocolConfig_Call { + _c.Call.Return(protocolConfigResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiGetProtocolConfig_Call) RunAndReturn(run func(ctx context.Context, req models.SuiGetProtocolConfigRequest) (models.ProtocolConfigResponse, error)) *MockISuiAPI_SuiGetProtocolConfig_Call { + _c.Call.Return(run) + return _c +} + +// SuiGetTotalTransactionBlocks provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiGetTotalTransactionBlocks(ctx context.Context) (uint64, error) { + ret := _mock.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for SuiGetTotalTransactionBlocks") + } + + var r0 uint64 + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context) (uint64, error)); ok { + return returnFunc(ctx) + } + if returnFunc, ok := ret.Get(0).(func(context.Context) uint64); ok { + r0 = returnFunc(ctx) + } else { + r0 = ret.Get(0).(uint64) + } + if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = returnFunc(ctx) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiGetTotalTransactionBlocks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiGetTotalTransactionBlocks' +type MockISuiAPI_SuiGetTotalTransactionBlocks_Call struct { + *mock.Call +} + +// SuiGetTotalTransactionBlocks is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockISuiAPI_Expecter) SuiGetTotalTransactionBlocks(ctx interface{}) *MockISuiAPI_SuiGetTotalTransactionBlocks_Call { + return &MockISuiAPI_SuiGetTotalTransactionBlocks_Call{Call: _e.mock.On("SuiGetTotalTransactionBlocks", ctx)} +} + +func (_c *MockISuiAPI_SuiGetTotalTransactionBlocks_Call) Run(run func(ctx context.Context)) *MockISuiAPI_SuiGetTotalTransactionBlocks_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiGetTotalTransactionBlocks_Call) Return(v uint64, err error) *MockISuiAPI_SuiGetTotalTransactionBlocks_Call { + _c.Call.Return(v, err) + return _c +} + +func (_c *MockISuiAPI_SuiGetTotalTransactionBlocks_Call) RunAndReturn(run func(ctx context.Context) (uint64, error)) *MockISuiAPI_SuiGetTotalTransactionBlocks_Call { + _c.Call.Return(run) + return _c +} + +// SuiGetTransactionBlock provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiGetTransactionBlock(ctx context.Context, req models.SuiGetTransactionBlockRequest) (models.SuiTransactionBlockResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetTransactionBlock") + } + + var r0 models.SuiTransactionBlockResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiGetTransactionBlockRequest) (models.SuiTransactionBlockResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiGetTransactionBlockRequest) models.SuiTransactionBlockResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiTransactionBlockResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiGetTransactionBlockRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiGetTransactionBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiGetTransactionBlock' +type MockISuiAPI_SuiGetTransactionBlock_Call struct { + *mock.Call +} + +// SuiGetTransactionBlock is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiGetTransactionBlockRequest +func (_e *MockISuiAPI_Expecter) SuiGetTransactionBlock(ctx interface{}, req interface{}) *MockISuiAPI_SuiGetTransactionBlock_Call { + return &MockISuiAPI_SuiGetTransactionBlock_Call{Call: _e.mock.On("SuiGetTransactionBlock", ctx, req)} +} + +func (_c *MockISuiAPI_SuiGetTransactionBlock_Call) Run(run func(ctx context.Context, req models.SuiGetTransactionBlockRequest)) *MockISuiAPI_SuiGetTransactionBlock_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiGetTransactionBlockRequest + if args[1] != nil { + arg1 = args[1].(models.SuiGetTransactionBlockRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiGetTransactionBlock_Call) Return(suiTransactionBlockResponse models.SuiTransactionBlockResponse, err error) *MockISuiAPI_SuiGetTransactionBlock_Call { + _c.Call.Return(suiTransactionBlockResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiGetTransactionBlock_Call) RunAndReturn(run func(ctx context.Context, req models.SuiGetTransactionBlockRequest) (models.SuiTransactionBlockResponse, error)) *MockISuiAPI_SuiGetTransactionBlock_Call { + _c.Call.Return(run) + return _c +} + +// SuiMultiGetObjects provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiMultiGetObjects(ctx context.Context, req models.SuiMultiGetObjectsRequest) ([]*models.SuiObjectResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiMultiGetObjects") + } + + var r0 []*models.SuiObjectResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiMultiGetObjectsRequest) ([]*models.SuiObjectResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiMultiGetObjectsRequest) []*models.SuiObjectResponse); ok { + r0 = returnFunc(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*models.SuiObjectResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiMultiGetObjectsRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiMultiGetObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiMultiGetObjects' +type MockISuiAPI_SuiMultiGetObjects_Call struct { + *mock.Call +} + +// SuiMultiGetObjects is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiMultiGetObjectsRequest +func (_e *MockISuiAPI_Expecter) SuiMultiGetObjects(ctx interface{}, req interface{}) *MockISuiAPI_SuiMultiGetObjects_Call { + return &MockISuiAPI_SuiMultiGetObjects_Call{Call: _e.mock.On("SuiMultiGetObjects", ctx, req)} +} + +func (_c *MockISuiAPI_SuiMultiGetObjects_Call) Run(run func(ctx context.Context, req models.SuiMultiGetObjectsRequest)) *MockISuiAPI_SuiMultiGetObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiMultiGetObjectsRequest + if args[1] != nil { + arg1 = args[1].(models.SuiMultiGetObjectsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiMultiGetObjects_Call) Return(suiObjectResponses []*models.SuiObjectResponse, err error) *MockISuiAPI_SuiMultiGetObjects_Call { + _c.Call.Return(suiObjectResponses, err) + return _c +} + +func (_c *MockISuiAPI_SuiMultiGetObjects_Call) RunAndReturn(run func(ctx context.Context, req models.SuiMultiGetObjectsRequest) ([]*models.SuiObjectResponse, error)) *MockISuiAPI_SuiMultiGetObjects_Call { + _c.Call.Return(run) + return _c +} + +// SuiMultiGetTransactionBlocks provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiMultiGetTransactionBlocks(ctx context.Context, req models.SuiMultiGetTransactionBlocksRequest) (models.SuiMultiGetTransactionBlocksResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiMultiGetTransactionBlocks") + } + + var r0 models.SuiMultiGetTransactionBlocksResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiMultiGetTransactionBlocksRequest) (models.SuiMultiGetTransactionBlocksResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiMultiGetTransactionBlocksRequest) models.SuiMultiGetTransactionBlocksResponse); ok { + r0 = returnFunc(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(models.SuiMultiGetTransactionBlocksResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiMultiGetTransactionBlocksRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiMultiGetTransactionBlocks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiMultiGetTransactionBlocks' +type MockISuiAPI_SuiMultiGetTransactionBlocks_Call struct { + *mock.Call +} + +// SuiMultiGetTransactionBlocks is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiMultiGetTransactionBlocksRequest +func (_e *MockISuiAPI_Expecter) SuiMultiGetTransactionBlocks(ctx interface{}, req interface{}) *MockISuiAPI_SuiMultiGetTransactionBlocks_Call { + return &MockISuiAPI_SuiMultiGetTransactionBlocks_Call{Call: _e.mock.On("SuiMultiGetTransactionBlocks", ctx, req)} +} + +func (_c *MockISuiAPI_SuiMultiGetTransactionBlocks_Call) Run(run func(ctx context.Context, req models.SuiMultiGetTransactionBlocksRequest)) *MockISuiAPI_SuiMultiGetTransactionBlocks_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiMultiGetTransactionBlocksRequest + if args[1] != nil { + arg1 = args[1].(models.SuiMultiGetTransactionBlocksRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiMultiGetTransactionBlocks_Call) Return(suiMultiGetTransactionBlocksResponse models.SuiMultiGetTransactionBlocksResponse, err error) *MockISuiAPI_SuiMultiGetTransactionBlocks_Call { + _c.Call.Return(suiMultiGetTransactionBlocksResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiMultiGetTransactionBlocks_Call) RunAndReturn(run func(ctx context.Context, req models.SuiMultiGetTransactionBlocksRequest) (models.SuiMultiGetTransactionBlocksResponse, error)) *MockISuiAPI_SuiMultiGetTransactionBlocks_Call { + _c.Call.Return(run) + return _c +} + +// SuiTryGetPastObject provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiTryGetPastObject(ctx context.Context, req models.SuiTryGetPastObjectRequest) (models.PastObjectResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiTryGetPastObject") + } + + var r0 models.PastObjectResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiTryGetPastObjectRequest) (models.PastObjectResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiTryGetPastObjectRequest) models.PastObjectResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.PastObjectResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiTryGetPastObjectRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiTryGetPastObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiTryGetPastObject' +type MockISuiAPI_SuiTryGetPastObject_Call struct { + *mock.Call +} + +// SuiTryGetPastObject is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiTryGetPastObjectRequest +func (_e *MockISuiAPI_Expecter) SuiTryGetPastObject(ctx interface{}, req interface{}) *MockISuiAPI_SuiTryGetPastObject_Call { + return &MockISuiAPI_SuiTryGetPastObject_Call{Call: _e.mock.On("SuiTryGetPastObject", ctx, req)} +} + +func (_c *MockISuiAPI_SuiTryGetPastObject_Call) Run(run func(ctx context.Context, req models.SuiTryGetPastObjectRequest)) *MockISuiAPI_SuiTryGetPastObject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiTryGetPastObjectRequest + if args[1] != nil { + arg1 = args[1].(models.SuiTryGetPastObjectRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiTryGetPastObject_Call) Return(pastObjectResponse models.PastObjectResponse, err error) *MockISuiAPI_SuiTryGetPastObject_Call { + _c.Call.Return(pastObjectResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiTryGetPastObject_Call) RunAndReturn(run func(ctx context.Context, req models.SuiTryGetPastObjectRequest) (models.PastObjectResponse, error)) *MockISuiAPI_SuiTryGetPastObject_Call { + _c.Call.Return(run) + return _c +} + +// SuiTryMultiGetPastObjects provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiTryMultiGetPastObjects(ctx context.Context, req models.SuiTryMultiGetPastObjectsRequest) ([]*models.PastObjectResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiTryMultiGetPastObjects") + } + + var r0 []*models.PastObjectResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiTryMultiGetPastObjectsRequest) ([]*models.PastObjectResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiTryMultiGetPastObjectsRequest) []*models.PastObjectResponse); ok { + r0 = returnFunc(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*models.PastObjectResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiTryMultiGetPastObjectsRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiTryMultiGetPastObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiTryMultiGetPastObjects' +type MockISuiAPI_SuiTryMultiGetPastObjects_Call struct { + *mock.Call +} + +// SuiTryMultiGetPastObjects is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiTryMultiGetPastObjectsRequest +func (_e *MockISuiAPI_Expecter) SuiTryMultiGetPastObjects(ctx interface{}, req interface{}) *MockISuiAPI_SuiTryMultiGetPastObjects_Call { + return &MockISuiAPI_SuiTryMultiGetPastObjects_Call{Call: _e.mock.On("SuiTryMultiGetPastObjects", ctx, req)} +} + +func (_c *MockISuiAPI_SuiTryMultiGetPastObjects_Call) Run(run func(ctx context.Context, req models.SuiTryMultiGetPastObjectsRequest)) *MockISuiAPI_SuiTryMultiGetPastObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiTryMultiGetPastObjectsRequest + if args[1] != nil { + arg1 = args[1].(models.SuiTryMultiGetPastObjectsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiTryMultiGetPastObjects_Call) Return(pastObjectResponses []*models.PastObjectResponse, err error) *MockISuiAPI_SuiTryMultiGetPastObjects_Call { + _c.Call.Return(pastObjectResponses, err) + return _c +} + +func (_c *MockISuiAPI_SuiTryMultiGetPastObjects_Call) RunAndReturn(run func(ctx context.Context, req models.SuiTryMultiGetPastObjectsRequest) ([]*models.PastObjectResponse, error)) *MockISuiAPI_SuiTryMultiGetPastObjects_Call { + _c.Call.Return(run) + return _c +} + +// SuiXGetAllBalance provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXGetAllBalance(ctx context.Context, req models.SuiXGetAllBalanceRequest) (models.CoinAllBalanceResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetAllBalance") + } + + var r0 models.CoinAllBalanceResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetAllBalanceRequest) (models.CoinAllBalanceResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetAllBalanceRequest) models.CoinAllBalanceResponse); ok { + r0 = returnFunc(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(models.CoinAllBalanceResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiXGetAllBalanceRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXGetAllBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXGetAllBalance' +type MockISuiAPI_SuiXGetAllBalance_Call struct { + *mock.Call +} + +// SuiXGetAllBalance is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiXGetAllBalanceRequest +func (_e *MockISuiAPI_Expecter) SuiXGetAllBalance(ctx interface{}, req interface{}) *MockISuiAPI_SuiXGetAllBalance_Call { + return &MockISuiAPI_SuiXGetAllBalance_Call{Call: _e.mock.On("SuiXGetAllBalance", ctx, req)} +} + +func (_c *MockISuiAPI_SuiXGetAllBalance_Call) Run(run func(ctx context.Context, req models.SuiXGetAllBalanceRequest)) *MockISuiAPI_SuiXGetAllBalance_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiXGetAllBalanceRequest + if args[1] != nil { + arg1 = args[1].(models.SuiXGetAllBalanceRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXGetAllBalance_Call) Return(coinAllBalanceResponse models.CoinAllBalanceResponse, err error) *MockISuiAPI_SuiXGetAllBalance_Call { + _c.Call.Return(coinAllBalanceResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiXGetAllBalance_Call) RunAndReturn(run func(ctx context.Context, req models.SuiXGetAllBalanceRequest) (models.CoinAllBalanceResponse, error)) *MockISuiAPI_SuiXGetAllBalance_Call { + _c.Call.Return(run) + return _c +} + +// SuiXGetAllCoins provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXGetAllCoins(ctx context.Context, req models.SuiXGetAllCoinsRequest) (models.PaginatedCoinsResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetAllCoins") + } + + var r0 models.PaginatedCoinsResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetAllCoinsRequest) (models.PaginatedCoinsResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetAllCoinsRequest) models.PaginatedCoinsResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.PaginatedCoinsResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiXGetAllCoinsRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXGetAllCoins_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXGetAllCoins' +type MockISuiAPI_SuiXGetAllCoins_Call struct { + *mock.Call +} + +// SuiXGetAllCoins is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiXGetAllCoinsRequest +func (_e *MockISuiAPI_Expecter) SuiXGetAllCoins(ctx interface{}, req interface{}) *MockISuiAPI_SuiXGetAllCoins_Call { + return &MockISuiAPI_SuiXGetAllCoins_Call{Call: _e.mock.On("SuiXGetAllCoins", ctx, req)} +} + +func (_c *MockISuiAPI_SuiXGetAllCoins_Call) Run(run func(ctx context.Context, req models.SuiXGetAllCoinsRequest)) *MockISuiAPI_SuiXGetAllCoins_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiXGetAllCoinsRequest + if args[1] != nil { + arg1 = args[1].(models.SuiXGetAllCoinsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXGetAllCoins_Call) Return(paginatedCoinsResponse models.PaginatedCoinsResponse, err error) *MockISuiAPI_SuiXGetAllCoins_Call { + _c.Call.Return(paginatedCoinsResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiXGetAllCoins_Call) RunAndReturn(run func(ctx context.Context, req models.SuiXGetAllCoinsRequest) (models.PaginatedCoinsResponse, error)) *MockISuiAPI_SuiXGetAllCoins_Call { + _c.Call.Return(run) + return _c +} + +// SuiXGetBalance provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXGetBalance(ctx context.Context, req models.SuiXGetBalanceRequest) (models.CoinBalanceResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetBalance") + } + + var r0 models.CoinBalanceResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetBalanceRequest) (models.CoinBalanceResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetBalanceRequest) models.CoinBalanceResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.CoinBalanceResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiXGetBalanceRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXGetBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXGetBalance' +type MockISuiAPI_SuiXGetBalance_Call struct { + *mock.Call +} + +// SuiXGetBalance is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiXGetBalanceRequest +func (_e *MockISuiAPI_Expecter) SuiXGetBalance(ctx interface{}, req interface{}) *MockISuiAPI_SuiXGetBalance_Call { + return &MockISuiAPI_SuiXGetBalance_Call{Call: _e.mock.On("SuiXGetBalance", ctx, req)} +} + +func (_c *MockISuiAPI_SuiXGetBalance_Call) Run(run func(ctx context.Context, req models.SuiXGetBalanceRequest)) *MockISuiAPI_SuiXGetBalance_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiXGetBalanceRequest + if args[1] != nil { + arg1 = args[1].(models.SuiXGetBalanceRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXGetBalance_Call) Return(coinBalanceResponse models.CoinBalanceResponse, err error) *MockISuiAPI_SuiXGetBalance_Call { + _c.Call.Return(coinBalanceResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiXGetBalance_Call) RunAndReturn(run func(ctx context.Context, req models.SuiXGetBalanceRequest) (models.CoinBalanceResponse, error)) *MockISuiAPI_SuiXGetBalance_Call { + _c.Call.Return(run) + return _c +} + +// SuiXGetCoinMetadata provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXGetCoinMetadata(ctx context.Context, req models.SuiXGetCoinMetadataRequest) (models.CoinMetadataResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetCoinMetadata") + } + + var r0 models.CoinMetadataResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetCoinMetadataRequest) (models.CoinMetadataResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetCoinMetadataRequest) models.CoinMetadataResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.CoinMetadataResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiXGetCoinMetadataRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXGetCoinMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXGetCoinMetadata' +type MockISuiAPI_SuiXGetCoinMetadata_Call struct { + *mock.Call +} + +// SuiXGetCoinMetadata is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiXGetCoinMetadataRequest +func (_e *MockISuiAPI_Expecter) SuiXGetCoinMetadata(ctx interface{}, req interface{}) *MockISuiAPI_SuiXGetCoinMetadata_Call { + return &MockISuiAPI_SuiXGetCoinMetadata_Call{Call: _e.mock.On("SuiXGetCoinMetadata", ctx, req)} +} + +func (_c *MockISuiAPI_SuiXGetCoinMetadata_Call) Run(run func(ctx context.Context, req models.SuiXGetCoinMetadataRequest)) *MockISuiAPI_SuiXGetCoinMetadata_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiXGetCoinMetadataRequest + if args[1] != nil { + arg1 = args[1].(models.SuiXGetCoinMetadataRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXGetCoinMetadata_Call) Return(coinMetadataResponse models.CoinMetadataResponse, err error) *MockISuiAPI_SuiXGetCoinMetadata_Call { + _c.Call.Return(coinMetadataResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiXGetCoinMetadata_Call) RunAndReturn(run func(ctx context.Context, req models.SuiXGetCoinMetadataRequest) (models.CoinMetadataResponse, error)) *MockISuiAPI_SuiXGetCoinMetadata_Call { + _c.Call.Return(run) + return _c +} + +// SuiXGetCoins provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXGetCoins(ctx context.Context, req models.SuiXGetCoinsRequest) (models.PaginatedCoinsResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetCoins") + } + + var r0 models.PaginatedCoinsResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetCoinsRequest) (models.PaginatedCoinsResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetCoinsRequest) models.PaginatedCoinsResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.PaginatedCoinsResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiXGetCoinsRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXGetCoins_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXGetCoins' +type MockISuiAPI_SuiXGetCoins_Call struct { + *mock.Call +} + +// SuiXGetCoins is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiXGetCoinsRequest +func (_e *MockISuiAPI_Expecter) SuiXGetCoins(ctx interface{}, req interface{}) *MockISuiAPI_SuiXGetCoins_Call { + return &MockISuiAPI_SuiXGetCoins_Call{Call: _e.mock.On("SuiXGetCoins", ctx, req)} +} + +func (_c *MockISuiAPI_SuiXGetCoins_Call) Run(run func(ctx context.Context, req models.SuiXGetCoinsRequest)) *MockISuiAPI_SuiXGetCoins_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiXGetCoinsRequest + if args[1] != nil { + arg1 = args[1].(models.SuiXGetCoinsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXGetCoins_Call) Return(paginatedCoinsResponse models.PaginatedCoinsResponse, err error) *MockISuiAPI_SuiXGetCoins_Call { + _c.Call.Return(paginatedCoinsResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiXGetCoins_Call) RunAndReturn(run func(ctx context.Context, req models.SuiXGetCoinsRequest) (models.PaginatedCoinsResponse, error)) *MockISuiAPI_SuiXGetCoins_Call { + _c.Call.Return(run) + return _c +} + +// SuiXGetCommitteeInfo provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXGetCommitteeInfo(ctx context.Context, req models.SuiXGetCommitteeInfoRequest) (models.SuiXGetCommitteeInfoResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetCommitteeInfo") + } + + var r0 models.SuiXGetCommitteeInfoResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetCommitteeInfoRequest) (models.SuiXGetCommitteeInfoResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetCommitteeInfoRequest) models.SuiXGetCommitteeInfoResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiXGetCommitteeInfoResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiXGetCommitteeInfoRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXGetCommitteeInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXGetCommitteeInfo' +type MockISuiAPI_SuiXGetCommitteeInfo_Call struct { + *mock.Call +} + +// SuiXGetCommitteeInfo is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiXGetCommitteeInfoRequest +func (_e *MockISuiAPI_Expecter) SuiXGetCommitteeInfo(ctx interface{}, req interface{}) *MockISuiAPI_SuiXGetCommitteeInfo_Call { + return &MockISuiAPI_SuiXGetCommitteeInfo_Call{Call: _e.mock.On("SuiXGetCommitteeInfo", ctx, req)} +} + +func (_c *MockISuiAPI_SuiXGetCommitteeInfo_Call) Run(run func(ctx context.Context, req models.SuiXGetCommitteeInfoRequest)) *MockISuiAPI_SuiXGetCommitteeInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiXGetCommitteeInfoRequest + if args[1] != nil { + arg1 = args[1].(models.SuiXGetCommitteeInfoRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXGetCommitteeInfo_Call) Return(suiXGetCommitteeInfoResponse models.SuiXGetCommitteeInfoResponse, err error) *MockISuiAPI_SuiXGetCommitteeInfo_Call { + _c.Call.Return(suiXGetCommitteeInfoResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiXGetCommitteeInfo_Call) RunAndReturn(run func(ctx context.Context, req models.SuiXGetCommitteeInfoRequest) (models.SuiXGetCommitteeInfoResponse, error)) *MockISuiAPI_SuiXGetCommitteeInfo_Call { + _c.Call.Return(run) + return _c +} + +// SuiXGetCurrentEpoch provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXGetCurrentEpoch(ctx context.Context) (models.EpochInfo, error) { + ret := _mock.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetCurrentEpoch") + } + + var r0 models.EpochInfo + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context) (models.EpochInfo, error)); ok { + return returnFunc(ctx) + } + if returnFunc, ok := ret.Get(0).(func(context.Context) models.EpochInfo); ok { + r0 = returnFunc(ctx) + } else { + r0 = ret.Get(0).(models.EpochInfo) + } + if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = returnFunc(ctx) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXGetCurrentEpoch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXGetCurrentEpoch' +type MockISuiAPI_SuiXGetCurrentEpoch_Call struct { + *mock.Call +} + +// SuiXGetCurrentEpoch is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockISuiAPI_Expecter) SuiXGetCurrentEpoch(ctx interface{}) *MockISuiAPI_SuiXGetCurrentEpoch_Call { + return &MockISuiAPI_SuiXGetCurrentEpoch_Call{Call: _e.mock.On("SuiXGetCurrentEpoch", ctx)} +} + +func (_c *MockISuiAPI_SuiXGetCurrentEpoch_Call) Run(run func(ctx context.Context)) *MockISuiAPI_SuiXGetCurrentEpoch_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXGetCurrentEpoch_Call) Return(epochInfo models.EpochInfo, err error) *MockISuiAPI_SuiXGetCurrentEpoch_Call { + _c.Call.Return(epochInfo, err) + return _c +} + +func (_c *MockISuiAPI_SuiXGetCurrentEpoch_Call) RunAndReturn(run func(ctx context.Context) (models.EpochInfo, error)) *MockISuiAPI_SuiXGetCurrentEpoch_Call { + _c.Call.Return(run) + return _c +} + +// SuiXGetDynamicField provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXGetDynamicField(ctx context.Context, req models.SuiXGetDynamicFieldRequest) (models.PaginatedDynamicFieldInfoResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetDynamicField") + } + + var r0 models.PaginatedDynamicFieldInfoResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetDynamicFieldRequest) (models.PaginatedDynamicFieldInfoResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetDynamicFieldRequest) models.PaginatedDynamicFieldInfoResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.PaginatedDynamicFieldInfoResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiXGetDynamicFieldRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXGetDynamicField_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXGetDynamicField' +type MockISuiAPI_SuiXGetDynamicField_Call struct { + *mock.Call +} + +// SuiXGetDynamicField is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiXGetDynamicFieldRequest +func (_e *MockISuiAPI_Expecter) SuiXGetDynamicField(ctx interface{}, req interface{}) *MockISuiAPI_SuiXGetDynamicField_Call { + return &MockISuiAPI_SuiXGetDynamicField_Call{Call: _e.mock.On("SuiXGetDynamicField", ctx, req)} +} + +func (_c *MockISuiAPI_SuiXGetDynamicField_Call) Run(run func(ctx context.Context, req models.SuiXGetDynamicFieldRequest)) *MockISuiAPI_SuiXGetDynamicField_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiXGetDynamicFieldRequest + if args[1] != nil { + arg1 = args[1].(models.SuiXGetDynamicFieldRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXGetDynamicField_Call) Return(paginatedDynamicFieldInfoResponse models.PaginatedDynamicFieldInfoResponse, err error) *MockISuiAPI_SuiXGetDynamicField_Call { + _c.Call.Return(paginatedDynamicFieldInfoResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiXGetDynamicField_Call) RunAndReturn(run func(ctx context.Context, req models.SuiXGetDynamicFieldRequest) (models.PaginatedDynamicFieldInfoResponse, error)) *MockISuiAPI_SuiXGetDynamicField_Call { + _c.Call.Return(run) + return _c +} + +// SuiXGetDynamicFieldObject provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXGetDynamicFieldObject(ctx context.Context, req models.SuiXGetDynamicFieldObjectRequest) (models.SuiObjectResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetDynamicFieldObject") + } + + var r0 models.SuiObjectResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetDynamicFieldObjectRequest) (models.SuiObjectResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetDynamicFieldObjectRequest) models.SuiObjectResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiObjectResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiXGetDynamicFieldObjectRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXGetDynamicFieldObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXGetDynamicFieldObject' +type MockISuiAPI_SuiXGetDynamicFieldObject_Call struct { + *mock.Call +} + +// SuiXGetDynamicFieldObject is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiXGetDynamicFieldObjectRequest +func (_e *MockISuiAPI_Expecter) SuiXGetDynamicFieldObject(ctx interface{}, req interface{}) *MockISuiAPI_SuiXGetDynamicFieldObject_Call { + return &MockISuiAPI_SuiXGetDynamicFieldObject_Call{Call: _e.mock.On("SuiXGetDynamicFieldObject", ctx, req)} +} + +func (_c *MockISuiAPI_SuiXGetDynamicFieldObject_Call) Run(run func(ctx context.Context, req models.SuiXGetDynamicFieldObjectRequest)) *MockISuiAPI_SuiXGetDynamicFieldObject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiXGetDynamicFieldObjectRequest + if args[1] != nil { + arg1 = args[1].(models.SuiXGetDynamicFieldObjectRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXGetDynamicFieldObject_Call) Return(suiObjectResponse models.SuiObjectResponse, err error) *MockISuiAPI_SuiXGetDynamicFieldObject_Call { + _c.Call.Return(suiObjectResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiXGetDynamicFieldObject_Call) RunAndReturn(run func(ctx context.Context, req models.SuiXGetDynamicFieldObjectRequest) (models.SuiObjectResponse, error)) *MockISuiAPI_SuiXGetDynamicFieldObject_Call { + _c.Call.Return(run) + return _c +} + +// SuiXGetEpochs provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXGetEpochs(ctx context.Context, req models.SuiXGetEpochsRequest) (models.PaginatedEpochInfoResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetEpochs") + } + + var r0 models.PaginatedEpochInfoResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetEpochsRequest) (models.PaginatedEpochInfoResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetEpochsRequest) models.PaginatedEpochInfoResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.PaginatedEpochInfoResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiXGetEpochsRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXGetEpochs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXGetEpochs' +type MockISuiAPI_SuiXGetEpochs_Call struct { + *mock.Call +} + +// SuiXGetEpochs is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiXGetEpochsRequest +func (_e *MockISuiAPI_Expecter) SuiXGetEpochs(ctx interface{}, req interface{}) *MockISuiAPI_SuiXGetEpochs_Call { + return &MockISuiAPI_SuiXGetEpochs_Call{Call: _e.mock.On("SuiXGetEpochs", ctx, req)} +} + +func (_c *MockISuiAPI_SuiXGetEpochs_Call) Run(run func(ctx context.Context, req models.SuiXGetEpochsRequest)) *MockISuiAPI_SuiXGetEpochs_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiXGetEpochsRequest + if args[1] != nil { + arg1 = args[1].(models.SuiXGetEpochsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXGetEpochs_Call) Return(paginatedEpochInfoResponse models.PaginatedEpochInfoResponse, err error) *MockISuiAPI_SuiXGetEpochs_Call { + _c.Call.Return(paginatedEpochInfoResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiXGetEpochs_Call) RunAndReturn(run func(ctx context.Context, req models.SuiXGetEpochsRequest) (models.PaginatedEpochInfoResponse, error)) *MockISuiAPI_SuiXGetEpochs_Call { + _c.Call.Return(run) + return _c +} + +// SuiXGetLatestSuiSystemState provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXGetLatestSuiSystemState(ctx context.Context) (models.SuiSystemStateSummary, error) { + ret := _mock.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetLatestSuiSystemState") + } + + var r0 models.SuiSystemStateSummary + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context) (models.SuiSystemStateSummary, error)); ok { + return returnFunc(ctx) + } + if returnFunc, ok := ret.Get(0).(func(context.Context) models.SuiSystemStateSummary); ok { + r0 = returnFunc(ctx) + } else { + r0 = ret.Get(0).(models.SuiSystemStateSummary) + } + if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = returnFunc(ctx) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXGetLatestSuiSystemState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXGetLatestSuiSystemState' +type MockISuiAPI_SuiXGetLatestSuiSystemState_Call struct { + *mock.Call +} + +// SuiXGetLatestSuiSystemState is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockISuiAPI_Expecter) SuiXGetLatestSuiSystemState(ctx interface{}) *MockISuiAPI_SuiXGetLatestSuiSystemState_Call { + return &MockISuiAPI_SuiXGetLatestSuiSystemState_Call{Call: _e.mock.On("SuiXGetLatestSuiSystemState", ctx)} +} + +func (_c *MockISuiAPI_SuiXGetLatestSuiSystemState_Call) Run(run func(ctx context.Context)) *MockISuiAPI_SuiXGetLatestSuiSystemState_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXGetLatestSuiSystemState_Call) Return(suiSystemStateSummary models.SuiSystemStateSummary, err error) *MockISuiAPI_SuiXGetLatestSuiSystemState_Call { + _c.Call.Return(suiSystemStateSummary, err) + return _c +} + +func (_c *MockISuiAPI_SuiXGetLatestSuiSystemState_Call) RunAndReturn(run func(ctx context.Context) (models.SuiSystemStateSummary, error)) *MockISuiAPI_SuiXGetLatestSuiSystemState_Call { + _c.Call.Return(run) + return _c +} + +// SuiXGetOwnedObjects provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXGetOwnedObjects(ctx context.Context, req models.SuiXGetOwnedObjectsRequest) (models.PaginatedObjectsResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetOwnedObjects") + } + + var r0 models.PaginatedObjectsResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetOwnedObjectsRequest) (models.PaginatedObjectsResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetOwnedObjectsRequest) models.PaginatedObjectsResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.PaginatedObjectsResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiXGetOwnedObjectsRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXGetOwnedObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXGetOwnedObjects' +type MockISuiAPI_SuiXGetOwnedObjects_Call struct { + *mock.Call +} + +// SuiXGetOwnedObjects is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiXGetOwnedObjectsRequest +func (_e *MockISuiAPI_Expecter) SuiXGetOwnedObjects(ctx interface{}, req interface{}) *MockISuiAPI_SuiXGetOwnedObjects_Call { + return &MockISuiAPI_SuiXGetOwnedObjects_Call{Call: _e.mock.On("SuiXGetOwnedObjects", ctx, req)} +} + +func (_c *MockISuiAPI_SuiXGetOwnedObjects_Call) Run(run func(ctx context.Context, req models.SuiXGetOwnedObjectsRequest)) *MockISuiAPI_SuiXGetOwnedObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiXGetOwnedObjectsRequest + if args[1] != nil { + arg1 = args[1].(models.SuiXGetOwnedObjectsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXGetOwnedObjects_Call) Return(paginatedObjectsResponse models.PaginatedObjectsResponse, err error) *MockISuiAPI_SuiXGetOwnedObjects_Call { + _c.Call.Return(paginatedObjectsResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiXGetOwnedObjects_Call) RunAndReturn(run func(ctx context.Context, req models.SuiXGetOwnedObjectsRequest) (models.PaginatedObjectsResponse, error)) *MockISuiAPI_SuiXGetOwnedObjects_Call { + _c.Call.Return(run) + return _c +} + +// SuiXGetReferenceGasPrice provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXGetReferenceGasPrice(ctx context.Context) (uint64, error) { + ret := _mock.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetReferenceGasPrice") + } + + var r0 uint64 + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context) (uint64, error)); ok { + return returnFunc(ctx) + } + if returnFunc, ok := ret.Get(0).(func(context.Context) uint64); ok { + r0 = returnFunc(ctx) + } else { + r0 = ret.Get(0).(uint64) + } + if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = returnFunc(ctx) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXGetReferenceGasPrice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXGetReferenceGasPrice' +type MockISuiAPI_SuiXGetReferenceGasPrice_Call struct { + *mock.Call +} + +// SuiXGetReferenceGasPrice is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockISuiAPI_Expecter) SuiXGetReferenceGasPrice(ctx interface{}) *MockISuiAPI_SuiXGetReferenceGasPrice_Call { + return &MockISuiAPI_SuiXGetReferenceGasPrice_Call{Call: _e.mock.On("SuiXGetReferenceGasPrice", ctx)} +} + +func (_c *MockISuiAPI_SuiXGetReferenceGasPrice_Call) Run(run func(ctx context.Context)) *MockISuiAPI_SuiXGetReferenceGasPrice_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXGetReferenceGasPrice_Call) Return(v uint64, err error) *MockISuiAPI_SuiXGetReferenceGasPrice_Call { + _c.Call.Return(v, err) + return _c +} + +func (_c *MockISuiAPI_SuiXGetReferenceGasPrice_Call) RunAndReturn(run func(ctx context.Context) (uint64, error)) *MockISuiAPI_SuiXGetReferenceGasPrice_Call { + _c.Call.Return(run) + return _c +} + +// SuiXGetStakes provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXGetStakes(ctx context.Context, req models.SuiXGetStakesRequest) ([]*models.DelegatedStakesResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetStakes") + } + + var r0 []*models.DelegatedStakesResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetStakesRequest) ([]*models.DelegatedStakesResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetStakesRequest) []*models.DelegatedStakesResponse); ok { + r0 = returnFunc(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*models.DelegatedStakesResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiXGetStakesRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXGetStakes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXGetStakes' +type MockISuiAPI_SuiXGetStakes_Call struct { + *mock.Call +} + +// SuiXGetStakes is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiXGetStakesRequest +func (_e *MockISuiAPI_Expecter) SuiXGetStakes(ctx interface{}, req interface{}) *MockISuiAPI_SuiXGetStakes_Call { + return &MockISuiAPI_SuiXGetStakes_Call{Call: _e.mock.On("SuiXGetStakes", ctx, req)} +} + +func (_c *MockISuiAPI_SuiXGetStakes_Call) Run(run func(ctx context.Context, req models.SuiXGetStakesRequest)) *MockISuiAPI_SuiXGetStakes_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiXGetStakesRequest + if args[1] != nil { + arg1 = args[1].(models.SuiXGetStakesRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXGetStakes_Call) Return(delegatedStakesResponses []*models.DelegatedStakesResponse, err error) *MockISuiAPI_SuiXGetStakes_Call { + _c.Call.Return(delegatedStakesResponses, err) + return _c +} + +func (_c *MockISuiAPI_SuiXGetStakes_Call) RunAndReturn(run func(ctx context.Context, req models.SuiXGetStakesRequest) ([]*models.DelegatedStakesResponse, error)) *MockISuiAPI_SuiXGetStakes_Call { + _c.Call.Return(run) + return _c +} + +// SuiXGetStakesByIds provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXGetStakesByIds(ctx context.Context, req models.SuiXGetStakesByIdsRequest) ([]*models.DelegatedStakesResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetStakesByIds") + } + + var r0 []*models.DelegatedStakesResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetStakesByIdsRequest) ([]*models.DelegatedStakesResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetStakesByIdsRequest) []*models.DelegatedStakesResponse); ok { + r0 = returnFunc(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*models.DelegatedStakesResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiXGetStakesByIdsRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXGetStakesByIds_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXGetStakesByIds' +type MockISuiAPI_SuiXGetStakesByIds_Call struct { + *mock.Call +} + +// SuiXGetStakesByIds is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiXGetStakesByIdsRequest +func (_e *MockISuiAPI_Expecter) SuiXGetStakesByIds(ctx interface{}, req interface{}) *MockISuiAPI_SuiXGetStakesByIds_Call { + return &MockISuiAPI_SuiXGetStakesByIds_Call{Call: _e.mock.On("SuiXGetStakesByIds", ctx, req)} +} + +func (_c *MockISuiAPI_SuiXGetStakesByIds_Call) Run(run func(ctx context.Context, req models.SuiXGetStakesByIdsRequest)) *MockISuiAPI_SuiXGetStakesByIds_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiXGetStakesByIdsRequest + if args[1] != nil { + arg1 = args[1].(models.SuiXGetStakesByIdsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXGetStakesByIds_Call) Return(delegatedStakesResponses []*models.DelegatedStakesResponse, err error) *MockISuiAPI_SuiXGetStakesByIds_Call { + _c.Call.Return(delegatedStakesResponses, err) + return _c +} + +func (_c *MockISuiAPI_SuiXGetStakesByIds_Call) RunAndReturn(run func(ctx context.Context, req models.SuiXGetStakesByIdsRequest) ([]*models.DelegatedStakesResponse, error)) *MockISuiAPI_SuiXGetStakesByIds_Call { + _c.Call.Return(run) + return _c +} + +// SuiXGetTotalSupply provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXGetTotalSupply(ctx context.Context, req models.SuiXGetTotalSupplyRequest) (models.TotalSupplyResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetTotalSupply") + } + + var r0 models.TotalSupplyResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetTotalSupplyRequest) (models.TotalSupplyResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXGetTotalSupplyRequest) models.TotalSupplyResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.TotalSupplyResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiXGetTotalSupplyRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXGetTotalSupply_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXGetTotalSupply' +type MockISuiAPI_SuiXGetTotalSupply_Call struct { + *mock.Call +} + +// SuiXGetTotalSupply is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiXGetTotalSupplyRequest +func (_e *MockISuiAPI_Expecter) SuiXGetTotalSupply(ctx interface{}, req interface{}) *MockISuiAPI_SuiXGetTotalSupply_Call { + return &MockISuiAPI_SuiXGetTotalSupply_Call{Call: _e.mock.On("SuiXGetTotalSupply", ctx, req)} +} + +func (_c *MockISuiAPI_SuiXGetTotalSupply_Call) Run(run func(ctx context.Context, req models.SuiXGetTotalSupplyRequest)) *MockISuiAPI_SuiXGetTotalSupply_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiXGetTotalSupplyRequest + if args[1] != nil { + arg1 = args[1].(models.SuiXGetTotalSupplyRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXGetTotalSupply_Call) Return(totalSupplyResponse models.TotalSupplyResponse, err error) *MockISuiAPI_SuiXGetTotalSupply_Call { + _c.Call.Return(totalSupplyResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiXGetTotalSupply_Call) RunAndReturn(run func(ctx context.Context, req models.SuiXGetTotalSupplyRequest) (models.TotalSupplyResponse, error)) *MockISuiAPI_SuiXGetTotalSupply_Call { + _c.Call.Return(run) + return _c +} + +// SuiXGetValidatorsApy provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXGetValidatorsApy(ctx context.Context) (models.ValidatorsApy, error) { + ret := _mock.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetValidatorsApy") + } + + var r0 models.ValidatorsApy + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context) (models.ValidatorsApy, error)); ok { + return returnFunc(ctx) + } + if returnFunc, ok := ret.Get(0).(func(context.Context) models.ValidatorsApy); ok { + r0 = returnFunc(ctx) + } else { + r0 = ret.Get(0).(models.ValidatorsApy) + } + if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = returnFunc(ctx) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXGetValidatorsApy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXGetValidatorsApy' +type MockISuiAPI_SuiXGetValidatorsApy_Call struct { + *mock.Call +} + +// SuiXGetValidatorsApy is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockISuiAPI_Expecter) SuiXGetValidatorsApy(ctx interface{}) *MockISuiAPI_SuiXGetValidatorsApy_Call { + return &MockISuiAPI_SuiXGetValidatorsApy_Call{Call: _e.mock.On("SuiXGetValidatorsApy", ctx)} +} + +func (_c *MockISuiAPI_SuiXGetValidatorsApy_Call) Run(run func(ctx context.Context)) *MockISuiAPI_SuiXGetValidatorsApy_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXGetValidatorsApy_Call) Return(validatorsApy models.ValidatorsApy, err error) *MockISuiAPI_SuiXGetValidatorsApy_Call { + _c.Call.Return(validatorsApy, err) + return _c +} + +func (_c *MockISuiAPI_SuiXGetValidatorsApy_Call) RunAndReturn(run func(ctx context.Context) (models.ValidatorsApy, error)) *MockISuiAPI_SuiXGetValidatorsApy_Call { + _c.Call.Return(run) + return _c +} + +// SuiXQueryEvents provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXQueryEvents(ctx context.Context, req models.SuiXQueryEventsRequest) (models.PaginatedEventsResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXQueryEvents") + } + + var r0 models.PaginatedEventsResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXQueryEventsRequest) (models.PaginatedEventsResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXQueryEventsRequest) models.PaginatedEventsResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.PaginatedEventsResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiXQueryEventsRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXQueryEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXQueryEvents' +type MockISuiAPI_SuiXQueryEvents_Call struct { + *mock.Call +} + +// SuiXQueryEvents is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiXQueryEventsRequest +func (_e *MockISuiAPI_Expecter) SuiXQueryEvents(ctx interface{}, req interface{}) *MockISuiAPI_SuiXQueryEvents_Call { + return &MockISuiAPI_SuiXQueryEvents_Call{Call: _e.mock.On("SuiXQueryEvents", ctx, req)} +} + +func (_c *MockISuiAPI_SuiXQueryEvents_Call) Run(run func(ctx context.Context, req models.SuiXQueryEventsRequest)) *MockISuiAPI_SuiXQueryEvents_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiXQueryEventsRequest + if args[1] != nil { + arg1 = args[1].(models.SuiXQueryEventsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXQueryEvents_Call) Return(paginatedEventsResponse models.PaginatedEventsResponse, err error) *MockISuiAPI_SuiXQueryEvents_Call { + _c.Call.Return(paginatedEventsResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiXQueryEvents_Call) RunAndReturn(run func(ctx context.Context, req models.SuiXQueryEventsRequest) (models.PaginatedEventsResponse, error)) *MockISuiAPI_SuiXQueryEvents_Call { + _c.Call.Return(run) + return _c +} + +// SuiXQueryTransactionBlocks provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXQueryTransactionBlocks(ctx context.Context, req models.SuiXQueryTransactionBlocksRequest) (models.SuiXQueryTransactionBlocksResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXQueryTransactionBlocks") + } + + var r0 models.SuiXQueryTransactionBlocksResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXQueryTransactionBlocksRequest) (models.SuiXQueryTransactionBlocksResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXQueryTransactionBlocksRequest) models.SuiXQueryTransactionBlocksResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiXQueryTransactionBlocksResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiXQueryTransactionBlocksRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXQueryTransactionBlocks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXQueryTransactionBlocks' +type MockISuiAPI_SuiXQueryTransactionBlocks_Call struct { + *mock.Call +} + +// SuiXQueryTransactionBlocks is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiXQueryTransactionBlocksRequest +func (_e *MockISuiAPI_Expecter) SuiXQueryTransactionBlocks(ctx interface{}, req interface{}) *MockISuiAPI_SuiXQueryTransactionBlocks_Call { + return &MockISuiAPI_SuiXQueryTransactionBlocks_Call{Call: _e.mock.On("SuiXQueryTransactionBlocks", ctx, req)} +} + +func (_c *MockISuiAPI_SuiXQueryTransactionBlocks_Call) Run(run func(ctx context.Context, req models.SuiXQueryTransactionBlocksRequest)) *MockISuiAPI_SuiXQueryTransactionBlocks_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiXQueryTransactionBlocksRequest + if args[1] != nil { + arg1 = args[1].(models.SuiXQueryTransactionBlocksRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXQueryTransactionBlocks_Call) Return(suiXQueryTransactionBlocksResponse models.SuiXQueryTransactionBlocksResponse, err error) *MockISuiAPI_SuiXQueryTransactionBlocks_Call { + _c.Call.Return(suiXQueryTransactionBlocksResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiXQueryTransactionBlocks_Call) RunAndReturn(run func(ctx context.Context, req models.SuiXQueryTransactionBlocksRequest) (models.SuiXQueryTransactionBlocksResponse, error)) *MockISuiAPI_SuiXQueryTransactionBlocks_Call { + _c.Call.Return(run) + return _c +} + +// SuiXResolveNameServiceAddress provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXResolveNameServiceAddress(ctx context.Context, req models.SuiXResolveNameServiceAddressRequest) (string, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXResolveNameServiceAddress") + } + + var r0 string + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXResolveNameServiceAddressRequest) (string, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXResolveNameServiceAddressRequest) string); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(string) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiXResolveNameServiceAddressRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXResolveNameServiceAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXResolveNameServiceAddress' +type MockISuiAPI_SuiXResolveNameServiceAddress_Call struct { + *mock.Call +} + +// SuiXResolveNameServiceAddress is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiXResolveNameServiceAddressRequest +func (_e *MockISuiAPI_Expecter) SuiXResolveNameServiceAddress(ctx interface{}, req interface{}) *MockISuiAPI_SuiXResolveNameServiceAddress_Call { + return &MockISuiAPI_SuiXResolveNameServiceAddress_Call{Call: _e.mock.On("SuiXResolveNameServiceAddress", ctx, req)} +} + +func (_c *MockISuiAPI_SuiXResolveNameServiceAddress_Call) Run(run func(ctx context.Context, req models.SuiXResolveNameServiceAddressRequest)) *MockISuiAPI_SuiXResolveNameServiceAddress_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiXResolveNameServiceAddressRequest + if args[1] != nil { + arg1 = args[1].(models.SuiXResolveNameServiceAddressRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXResolveNameServiceAddress_Call) Return(s string, err error) *MockISuiAPI_SuiXResolveNameServiceAddress_Call { + _c.Call.Return(s, err) + return _c +} + +func (_c *MockISuiAPI_SuiXResolveNameServiceAddress_Call) RunAndReturn(run func(ctx context.Context, req models.SuiXResolveNameServiceAddressRequest) (string, error)) *MockISuiAPI_SuiXResolveNameServiceAddress_Call { + _c.Call.Return(run) + return _c +} + +// SuiXResolveNameServiceNames provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) SuiXResolveNameServiceNames(ctx context.Context, req models.SuiXResolveNameServiceNamesRequest) (models.SuiXResolveNameServiceNamesResponse, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXResolveNameServiceNames") + } + + var r0 models.SuiXResolveNameServiceNamesResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXResolveNameServiceNamesRequest) (models.SuiXResolveNameServiceNamesResponse, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.SuiXResolveNameServiceNamesRequest) models.SuiXResolveNameServiceNamesResponse); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiXResolveNameServiceNamesResponse) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.SuiXResolveNameServiceNamesRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_SuiXResolveNameServiceNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuiXResolveNameServiceNames' +type MockISuiAPI_SuiXResolveNameServiceNames_Call struct { + *mock.Call +} + +// SuiXResolveNameServiceNames is a helper method to define mock.On call +// - ctx context.Context +// - req models.SuiXResolveNameServiceNamesRequest +func (_e *MockISuiAPI_Expecter) SuiXResolveNameServiceNames(ctx interface{}, req interface{}) *MockISuiAPI_SuiXResolveNameServiceNames_Call { + return &MockISuiAPI_SuiXResolveNameServiceNames_Call{Call: _e.mock.On("SuiXResolveNameServiceNames", ctx, req)} +} + +func (_c *MockISuiAPI_SuiXResolveNameServiceNames_Call) Run(run func(ctx context.Context, req models.SuiXResolveNameServiceNamesRequest)) *MockISuiAPI_SuiXResolveNameServiceNames_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.SuiXResolveNameServiceNamesRequest + if args[1] != nil { + arg1 = args[1].(models.SuiXResolveNameServiceNamesRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_SuiXResolveNameServiceNames_Call) Return(suiXResolveNameServiceNamesResponse models.SuiXResolveNameServiceNamesResponse, err error) *MockISuiAPI_SuiXResolveNameServiceNames_Call { + _c.Call.Return(suiXResolveNameServiceNamesResponse, err) + return _c +} + +func (_c *MockISuiAPI_SuiXResolveNameServiceNames_Call) RunAndReturn(run func(ctx context.Context, req models.SuiXResolveNameServiceNamesRequest) (models.SuiXResolveNameServiceNamesResponse, error)) *MockISuiAPI_SuiXResolveNameServiceNames_Call { + _c.Call.Return(run) + return _c +} + +// TransferObject provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) TransferObject(ctx context.Context, req models.TransferObjectRequest) (models.TxnMetaData, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for TransferObject") + } + + var r0 models.TxnMetaData + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.TransferObjectRequest) (models.TxnMetaData, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.TransferObjectRequest) models.TxnMetaData); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.TransferObjectRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_TransferObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransferObject' +type MockISuiAPI_TransferObject_Call struct { + *mock.Call +} + +// TransferObject is a helper method to define mock.On call +// - ctx context.Context +// - req models.TransferObjectRequest +func (_e *MockISuiAPI_Expecter) TransferObject(ctx interface{}, req interface{}) *MockISuiAPI_TransferObject_Call { + return &MockISuiAPI_TransferObject_Call{Call: _e.mock.On("TransferObject", ctx, req)} +} + +func (_c *MockISuiAPI_TransferObject_Call) Run(run func(ctx context.Context, req models.TransferObjectRequest)) *MockISuiAPI_TransferObject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.TransferObjectRequest + if args[1] != nil { + arg1 = args[1].(models.TransferObjectRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_TransferObject_Call) Return(txnMetaData models.TxnMetaData, err error) *MockISuiAPI_TransferObject_Call { + _c.Call.Return(txnMetaData, err) + return _c +} + +func (_c *MockISuiAPI_TransferObject_Call) RunAndReturn(run func(ctx context.Context, req models.TransferObjectRequest) (models.TxnMetaData, error)) *MockISuiAPI_TransferObject_Call { + _c.Call.Return(run) + return _c +} + +// TransferSui provides a mock function for the type MockISuiAPI +func (_mock *MockISuiAPI) TransferSui(ctx context.Context, req models.TransferSuiRequest) (models.TxnMetaData, error) { + ret := _mock.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for TransferSui") + } + + var r0 models.TxnMetaData + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, models.TransferSuiRequest) (models.TxnMetaData, error)); ok { + return returnFunc(ctx, req) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, models.TransferSuiRequest) models.TxnMetaData); ok { + r0 = returnFunc(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, models.TransferSuiRequest) error); ok { + r1 = returnFunc(ctx, req) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockISuiAPI_TransferSui_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransferSui' +type MockISuiAPI_TransferSui_Call struct { + *mock.Call +} + +// TransferSui is a helper method to define mock.On call +// - ctx context.Context +// - req models.TransferSuiRequest +func (_e *MockISuiAPI_Expecter) TransferSui(ctx interface{}, req interface{}) *MockISuiAPI_TransferSui_Call { + return &MockISuiAPI_TransferSui_Call{Call: _e.mock.On("TransferSui", ctx, req)} +} + +func (_c *MockISuiAPI_TransferSui_Call) Run(run func(ctx context.Context, req models.TransferSuiRequest)) *MockISuiAPI_TransferSui_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 models.TransferSuiRequest + if args[1] != nil { + arg1 = args[1].(models.TransferSuiRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockISuiAPI_TransferSui_Call) Return(txnMetaData models.TxnMetaData, err error) *MockISuiAPI_TransferSui_Call { + _c.Call.Return(txnMetaData, err) + return _c +} + +func (_c *MockISuiAPI_TransferSui_Call) RunAndReturn(run func(ctx context.Context, req models.TransferSuiRequest) (models.TxnMetaData, error)) *MockISuiAPI_TransferSui_Call { + _c.Call.Return(run) + return _c +} diff --git a/chain/ton/mocks/api_client_wrapped.go b/chain/ton/mocks/api_client_wrapped.go new file mode 100644 index 000000000..b671fe0fe --- /dev/null +++ b/chain/ton/mocks/api_client_wrapped.go @@ -0,0 +1,1842 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify + +package mocks + +import ( + "context" + "time" + + mock "github.com/stretchr/testify/mock" + "github.com/xssnick/tonutils-go/address" + "github.com/xssnick/tonutils-go/liteclient" + "github.com/xssnick/tonutils-go/tlb" + "github.com/xssnick/tonutils-go/ton" + "github.com/xssnick/tonutils-go/tvm/cell" +) + +// NewMockAPIClientWrapped creates a new instance of MockAPIClientWrapped. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockAPIClientWrapped(t interface { + mock.TestingT + Cleanup(func()) +}) *MockAPIClientWrapped { + mock := &MockAPIClientWrapped{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + +// MockAPIClientWrapped is an autogenerated mock type for the APIClientWrapped type +type MockAPIClientWrapped struct { + mock.Mock +} + +type MockAPIClientWrapped_Expecter struct { + mock *mock.Mock +} + +func (_m *MockAPIClientWrapped) EXPECT() *MockAPIClientWrapped_Expecter { + return &MockAPIClientWrapped_Expecter{mock: &_m.Mock} +} + +// Client provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) Client() ton.LiteClient { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Client") + } + + var r0 ton.LiteClient + if returnFunc, ok := ret.Get(0).(func() ton.LiteClient); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(ton.LiteClient) + } + } + return r0 +} + +// MockAPIClientWrapped_Client_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Client' +type MockAPIClientWrapped_Client_Call struct { + *mock.Call +} + +// Client is a helper method to define mock.On call +func (_e *MockAPIClientWrapped_Expecter) Client() *MockAPIClientWrapped_Client_Call { + return &MockAPIClientWrapped_Client_Call{Call: _e.mock.On("Client")} +} + +func (_c *MockAPIClientWrapped_Client_Call) Run(run func()) *MockAPIClientWrapped_Client_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAPIClientWrapped_Client_Call) Return(liteClient ton.LiteClient) *MockAPIClientWrapped_Client_Call { + _c.Call.Return(liteClient) + return _c +} + +func (_c *MockAPIClientWrapped_Client_Call) RunAndReturn(run func() ton.LiteClient) *MockAPIClientWrapped_Client_Call { + _c.Call.Return(run) + return _c +} + +// CurrentMasterchainInfo provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) CurrentMasterchainInfo(ctx context.Context) (*ton.BlockIDExt, error) { + ret := _mock.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for CurrentMasterchainInfo") + } + + var r0 *ton.BlockIDExt + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context) (*ton.BlockIDExt, error)); ok { + return returnFunc(ctx) + } + if returnFunc, ok := ret.Get(0).(func(context.Context) *ton.BlockIDExt); ok { + r0 = returnFunc(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ton.BlockIDExt) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = returnFunc(ctx) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_CurrentMasterchainInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CurrentMasterchainInfo' +type MockAPIClientWrapped_CurrentMasterchainInfo_Call struct { + *mock.Call +} + +// CurrentMasterchainInfo is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockAPIClientWrapped_Expecter) CurrentMasterchainInfo(ctx interface{}) *MockAPIClientWrapped_CurrentMasterchainInfo_Call { + return &MockAPIClientWrapped_CurrentMasterchainInfo_Call{Call: _e.mock.On("CurrentMasterchainInfo", ctx)} +} + +func (_c *MockAPIClientWrapped_CurrentMasterchainInfo_Call) Run(run func(ctx context.Context)) *MockAPIClientWrapped_CurrentMasterchainInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_CurrentMasterchainInfo_Call) Return(v *ton.BlockIDExt, err error) *MockAPIClientWrapped_CurrentMasterchainInfo_Call { + _c.Call.Return(v, err) + return _c +} + +func (_c *MockAPIClientWrapped_CurrentMasterchainInfo_Call) RunAndReturn(run func(ctx context.Context) (*ton.BlockIDExt, error)) *MockAPIClientWrapped_CurrentMasterchainInfo_Call { + _c.Call.Return(run) + return _c +} + +// FindLastTransactionByInMsgHash provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) FindLastTransactionByInMsgHash(ctx context.Context, addr *address.Address, msgHash []byte, maxTxNumToScan ...int) (*tlb.Transaction, error) { + var tmpRet mock.Arguments + if len(maxTxNumToScan) > 0 { + tmpRet = _mock.Called(ctx, addr, msgHash, maxTxNumToScan) + } else { + tmpRet = _mock.Called(ctx, addr, msgHash) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for FindLastTransactionByInMsgHash") + } + + var r0 *tlb.Transaction + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *address.Address, []byte, ...int) (*tlb.Transaction, error)); ok { + return returnFunc(ctx, addr, msgHash, maxTxNumToScan...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *address.Address, []byte, ...int) *tlb.Transaction); ok { + r0 = returnFunc(ctx, addr, msgHash, maxTxNumToScan...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*tlb.Transaction) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *address.Address, []byte, ...int) error); ok { + r1 = returnFunc(ctx, addr, msgHash, maxTxNumToScan...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_FindLastTransactionByInMsgHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindLastTransactionByInMsgHash' +type MockAPIClientWrapped_FindLastTransactionByInMsgHash_Call struct { + *mock.Call +} + +// FindLastTransactionByInMsgHash is a helper method to define mock.On call +// - ctx context.Context +// - addr *address.Address +// - msgHash []byte +// - maxTxNumToScan ...int +func (_e *MockAPIClientWrapped_Expecter) FindLastTransactionByInMsgHash(ctx interface{}, addr interface{}, msgHash interface{}, maxTxNumToScan ...interface{}) *MockAPIClientWrapped_FindLastTransactionByInMsgHash_Call { + return &MockAPIClientWrapped_FindLastTransactionByInMsgHash_Call{Call: _e.mock.On("FindLastTransactionByInMsgHash", + append([]interface{}{ctx, addr, msgHash}, maxTxNumToScan...)...)} +} + +func (_c *MockAPIClientWrapped_FindLastTransactionByInMsgHash_Call) Run(run func(ctx context.Context, addr *address.Address, msgHash []byte, maxTxNumToScan ...int)) *MockAPIClientWrapped_FindLastTransactionByInMsgHash_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *address.Address + if args[1] != nil { + arg1 = args[1].(*address.Address) + } + var arg2 []byte + if args[2] != nil { + arg2 = args[2].([]byte) + } + var arg3 []int + var variadicArgs []int + if len(args) > 3 { + variadicArgs = args[3].([]int) + } + arg3 = variadicArgs + run( + arg0, + arg1, + arg2, + arg3..., + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_FindLastTransactionByInMsgHash_Call) Return(transaction *tlb.Transaction, err error) *MockAPIClientWrapped_FindLastTransactionByInMsgHash_Call { + _c.Call.Return(transaction, err) + return _c +} + +func (_c *MockAPIClientWrapped_FindLastTransactionByInMsgHash_Call) RunAndReturn(run func(ctx context.Context, addr *address.Address, msgHash []byte, maxTxNumToScan ...int) (*tlb.Transaction, error)) *MockAPIClientWrapped_FindLastTransactionByInMsgHash_Call { + _c.Call.Return(run) + return _c +} + +// FindLastTransactionByOutMsgHash provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) FindLastTransactionByOutMsgHash(ctx context.Context, addr *address.Address, msgHash []byte, maxTxNumToScan ...int) (*tlb.Transaction, error) { + var tmpRet mock.Arguments + if len(maxTxNumToScan) > 0 { + tmpRet = _mock.Called(ctx, addr, msgHash, maxTxNumToScan) + } else { + tmpRet = _mock.Called(ctx, addr, msgHash) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for FindLastTransactionByOutMsgHash") + } + + var r0 *tlb.Transaction + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *address.Address, []byte, ...int) (*tlb.Transaction, error)); ok { + return returnFunc(ctx, addr, msgHash, maxTxNumToScan...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *address.Address, []byte, ...int) *tlb.Transaction); ok { + r0 = returnFunc(ctx, addr, msgHash, maxTxNumToScan...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*tlb.Transaction) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *address.Address, []byte, ...int) error); ok { + r1 = returnFunc(ctx, addr, msgHash, maxTxNumToScan...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_FindLastTransactionByOutMsgHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindLastTransactionByOutMsgHash' +type MockAPIClientWrapped_FindLastTransactionByOutMsgHash_Call struct { + *mock.Call +} + +// FindLastTransactionByOutMsgHash is a helper method to define mock.On call +// - ctx context.Context +// - addr *address.Address +// - msgHash []byte +// - maxTxNumToScan ...int +func (_e *MockAPIClientWrapped_Expecter) FindLastTransactionByOutMsgHash(ctx interface{}, addr interface{}, msgHash interface{}, maxTxNumToScan ...interface{}) *MockAPIClientWrapped_FindLastTransactionByOutMsgHash_Call { + return &MockAPIClientWrapped_FindLastTransactionByOutMsgHash_Call{Call: _e.mock.On("FindLastTransactionByOutMsgHash", + append([]interface{}{ctx, addr, msgHash}, maxTxNumToScan...)...)} +} + +func (_c *MockAPIClientWrapped_FindLastTransactionByOutMsgHash_Call) Run(run func(ctx context.Context, addr *address.Address, msgHash []byte, maxTxNumToScan ...int)) *MockAPIClientWrapped_FindLastTransactionByOutMsgHash_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *address.Address + if args[1] != nil { + arg1 = args[1].(*address.Address) + } + var arg2 []byte + if args[2] != nil { + arg2 = args[2].([]byte) + } + var arg3 []int + var variadicArgs []int + if len(args) > 3 { + variadicArgs = args[3].([]int) + } + arg3 = variadicArgs + run( + arg0, + arg1, + arg2, + arg3..., + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_FindLastTransactionByOutMsgHash_Call) Return(transaction *tlb.Transaction, err error) *MockAPIClientWrapped_FindLastTransactionByOutMsgHash_Call { + _c.Call.Return(transaction, err) + return _c +} + +func (_c *MockAPIClientWrapped_FindLastTransactionByOutMsgHash_Call) RunAndReturn(run func(ctx context.Context, addr *address.Address, msgHash []byte, maxTxNumToScan ...int) (*tlb.Transaction, error)) *MockAPIClientWrapped_FindLastTransactionByOutMsgHash_Call { + _c.Call.Return(run) + return _c +} + +// GetAccount provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetAccount(ctx context.Context, block *ton.BlockIDExt, addr *address.Address) (*tlb.Account, error) { + ret := _mock.Called(ctx, block, addr) + + if len(ret) == 0 { + panic("no return value specified for GetAccount") + } + + var r0 *tlb.Account + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, *address.Address) (*tlb.Account, error)); ok { + return returnFunc(ctx, block, addr) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, *address.Address) *tlb.Account); ok { + r0 = returnFunc(ctx, block, addr) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*tlb.Account) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *ton.BlockIDExt, *address.Address) error); ok { + r1 = returnFunc(ctx, block, addr) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_GetAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAccount' +type MockAPIClientWrapped_GetAccount_Call struct { + *mock.Call +} + +// GetAccount is a helper method to define mock.On call +// - ctx context.Context +// - block *ton.BlockIDExt +// - addr *address.Address +func (_e *MockAPIClientWrapped_Expecter) GetAccount(ctx interface{}, block interface{}, addr interface{}) *MockAPIClientWrapped_GetAccount_Call { + return &MockAPIClientWrapped_GetAccount_Call{Call: _e.mock.On("GetAccount", ctx, block, addr)} +} + +func (_c *MockAPIClientWrapped_GetAccount_Call) Run(run func(ctx context.Context, block *ton.BlockIDExt, addr *address.Address)) *MockAPIClientWrapped_GetAccount_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *ton.BlockIDExt + if args[1] != nil { + arg1 = args[1].(*ton.BlockIDExt) + } + var arg2 *address.Address + if args[2] != nil { + arg2 = args[2].(*address.Address) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_GetAccount_Call) Return(account *tlb.Account, err error) *MockAPIClientWrapped_GetAccount_Call { + _c.Call.Return(account, err) + return _c +} + +func (_c *MockAPIClientWrapped_GetAccount_Call) RunAndReturn(run func(ctx context.Context, block *ton.BlockIDExt, addr *address.Address) (*tlb.Account, error)) *MockAPIClientWrapped_GetAccount_Call { + _c.Call.Return(run) + return _c +} + +// GetBlockData provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetBlockData(ctx context.Context, block *ton.BlockIDExt) (*tlb.Block, error) { + ret := _mock.Called(ctx, block) + + if len(ret) == 0 { + panic("no return value specified for GetBlockData") + } + + var r0 *tlb.Block + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt) (*tlb.Block, error)); ok { + return returnFunc(ctx, block) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt) *tlb.Block); ok { + r0 = returnFunc(ctx, block) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*tlb.Block) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *ton.BlockIDExt) error); ok { + r1 = returnFunc(ctx, block) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_GetBlockData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlockData' +type MockAPIClientWrapped_GetBlockData_Call struct { + *mock.Call +} + +// GetBlockData is a helper method to define mock.On call +// - ctx context.Context +// - block *ton.BlockIDExt +func (_e *MockAPIClientWrapped_Expecter) GetBlockData(ctx interface{}, block interface{}) *MockAPIClientWrapped_GetBlockData_Call { + return &MockAPIClientWrapped_GetBlockData_Call{Call: _e.mock.On("GetBlockData", ctx, block)} +} + +func (_c *MockAPIClientWrapped_GetBlockData_Call) Run(run func(ctx context.Context, block *ton.BlockIDExt)) *MockAPIClientWrapped_GetBlockData_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *ton.BlockIDExt + if args[1] != nil { + arg1 = args[1].(*ton.BlockIDExt) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_GetBlockData_Call) Return(block1 *tlb.Block, err error) *MockAPIClientWrapped_GetBlockData_Call { + _c.Call.Return(block1, err) + return _c +} + +func (_c *MockAPIClientWrapped_GetBlockData_Call) RunAndReturn(run func(ctx context.Context, block *ton.BlockIDExt) (*tlb.Block, error)) *MockAPIClientWrapped_GetBlockData_Call { + _c.Call.Return(run) + return _c +} + +// GetBlockProof provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetBlockProof(ctx context.Context, known *ton.BlockIDExt, target *ton.BlockIDExt) (*ton.PartialBlockProof, error) { + ret := _mock.Called(ctx, known, target) + + if len(ret) == 0 { + panic("no return value specified for GetBlockProof") + } + + var r0 *ton.PartialBlockProof + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, *ton.BlockIDExt) (*ton.PartialBlockProof, error)); ok { + return returnFunc(ctx, known, target) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, *ton.BlockIDExt) *ton.PartialBlockProof); ok { + r0 = returnFunc(ctx, known, target) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ton.PartialBlockProof) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *ton.BlockIDExt, *ton.BlockIDExt) error); ok { + r1 = returnFunc(ctx, known, target) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_GetBlockProof_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlockProof' +type MockAPIClientWrapped_GetBlockProof_Call struct { + *mock.Call +} + +// GetBlockProof is a helper method to define mock.On call +// - ctx context.Context +// - known *ton.BlockIDExt +// - target *ton.BlockIDExt +func (_e *MockAPIClientWrapped_Expecter) GetBlockProof(ctx interface{}, known interface{}, target interface{}) *MockAPIClientWrapped_GetBlockProof_Call { + return &MockAPIClientWrapped_GetBlockProof_Call{Call: _e.mock.On("GetBlockProof", ctx, known, target)} +} + +func (_c *MockAPIClientWrapped_GetBlockProof_Call) Run(run func(ctx context.Context, known *ton.BlockIDExt, target *ton.BlockIDExt)) *MockAPIClientWrapped_GetBlockProof_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *ton.BlockIDExt + if args[1] != nil { + arg1 = args[1].(*ton.BlockIDExt) + } + var arg2 *ton.BlockIDExt + if args[2] != nil { + arg2 = args[2].(*ton.BlockIDExt) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_GetBlockProof_Call) Return(partialBlockProof *ton.PartialBlockProof, err error) *MockAPIClientWrapped_GetBlockProof_Call { + _c.Call.Return(partialBlockProof, err) + return _c +} + +func (_c *MockAPIClientWrapped_GetBlockProof_Call) RunAndReturn(run func(ctx context.Context, known *ton.BlockIDExt, target *ton.BlockIDExt) (*ton.PartialBlockProof, error)) *MockAPIClientWrapped_GetBlockProof_Call { + _c.Call.Return(run) + return _c +} + +// GetBlockShardsInfo provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetBlockShardsInfo(ctx context.Context, master *ton.BlockIDExt) ([]*ton.BlockIDExt, error) { + ret := _mock.Called(ctx, master) + + if len(ret) == 0 { + panic("no return value specified for GetBlockShardsInfo") + } + + var r0 []*ton.BlockIDExt + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt) ([]*ton.BlockIDExt, error)); ok { + return returnFunc(ctx, master) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt) []*ton.BlockIDExt); ok { + r0 = returnFunc(ctx, master) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*ton.BlockIDExt) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *ton.BlockIDExt) error); ok { + r1 = returnFunc(ctx, master) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_GetBlockShardsInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlockShardsInfo' +type MockAPIClientWrapped_GetBlockShardsInfo_Call struct { + *mock.Call +} + +// GetBlockShardsInfo is a helper method to define mock.On call +// - ctx context.Context +// - master *ton.BlockIDExt +func (_e *MockAPIClientWrapped_Expecter) GetBlockShardsInfo(ctx interface{}, master interface{}) *MockAPIClientWrapped_GetBlockShardsInfo_Call { + return &MockAPIClientWrapped_GetBlockShardsInfo_Call{Call: _e.mock.On("GetBlockShardsInfo", ctx, master)} +} + +func (_c *MockAPIClientWrapped_GetBlockShardsInfo_Call) Run(run func(ctx context.Context, master *ton.BlockIDExt)) *MockAPIClientWrapped_GetBlockShardsInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *ton.BlockIDExt + if args[1] != nil { + arg1 = args[1].(*ton.BlockIDExt) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_GetBlockShardsInfo_Call) Return(vs []*ton.BlockIDExt, err error) *MockAPIClientWrapped_GetBlockShardsInfo_Call { + _c.Call.Return(vs, err) + return _c +} + +func (_c *MockAPIClientWrapped_GetBlockShardsInfo_Call) RunAndReturn(run func(ctx context.Context, master *ton.BlockIDExt) ([]*ton.BlockIDExt, error)) *MockAPIClientWrapped_GetBlockShardsInfo_Call { + _c.Call.Return(run) + return _c +} + +// GetBlockTransactionsV2 provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetBlockTransactionsV2(ctx context.Context, block *ton.BlockIDExt, count uint32, after ...*ton.TransactionID3) ([]ton.TransactionShortInfo, bool, error) { + var tmpRet mock.Arguments + if len(after) > 0 { + tmpRet = _mock.Called(ctx, block, count, after) + } else { + tmpRet = _mock.Called(ctx, block, count) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBlockTransactionsV2") + } + + var r0 []ton.TransactionShortInfo + var r1 bool + var r2 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, uint32, ...*ton.TransactionID3) ([]ton.TransactionShortInfo, bool, error)); ok { + return returnFunc(ctx, block, count, after...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, uint32, ...*ton.TransactionID3) []ton.TransactionShortInfo); ok { + r0 = returnFunc(ctx, block, count, after...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]ton.TransactionShortInfo) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *ton.BlockIDExt, uint32, ...*ton.TransactionID3) bool); ok { + r1 = returnFunc(ctx, block, count, after...) + } else { + r1 = ret.Get(1).(bool) + } + if returnFunc, ok := ret.Get(2).(func(context.Context, *ton.BlockIDExt, uint32, ...*ton.TransactionID3) error); ok { + r2 = returnFunc(ctx, block, count, after...) + } else { + r2 = ret.Error(2) + } + return r0, r1, r2 +} + +// MockAPIClientWrapped_GetBlockTransactionsV2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlockTransactionsV2' +type MockAPIClientWrapped_GetBlockTransactionsV2_Call struct { + *mock.Call +} + +// GetBlockTransactionsV2 is a helper method to define mock.On call +// - ctx context.Context +// - block *ton.BlockIDExt +// - count uint32 +// - after ...*ton.TransactionID3 +func (_e *MockAPIClientWrapped_Expecter) GetBlockTransactionsV2(ctx interface{}, block interface{}, count interface{}, after ...interface{}) *MockAPIClientWrapped_GetBlockTransactionsV2_Call { + return &MockAPIClientWrapped_GetBlockTransactionsV2_Call{Call: _e.mock.On("GetBlockTransactionsV2", + append([]interface{}{ctx, block, count}, after...)...)} +} + +func (_c *MockAPIClientWrapped_GetBlockTransactionsV2_Call) Run(run func(ctx context.Context, block *ton.BlockIDExt, count uint32, after ...*ton.TransactionID3)) *MockAPIClientWrapped_GetBlockTransactionsV2_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *ton.BlockIDExt + if args[1] != nil { + arg1 = args[1].(*ton.BlockIDExt) + } + var arg2 uint32 + if args[2] != nil { + arg2 = args[2].(uint32) + } + var arg3 []*ton.TransactionID3 + var variadicArgs []*ton.TransactionID3 + if len(args) > 3 { + variadicArgs = args[3].([]*ton.TransactionID3) + } + arg3 = variadicArgs + run( + arg0, + arg1, + arg2, + arg3..., + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_GetBlockTransactionsV2_Call) Return(transactionShortInfos []ton.TransactionShortInfo, b bool, err error) *MockAPIClientWrapped_GetBlockTransactionsV2_Call { + _c.Call.Return(transactionShortInfos, b, err) + return _c +} + +func (_c *MockAPIClientWrapped_GetBlockTransactionsV2_Call) RunAndReturn(run func(ctx context.Context, block *ton.BlockIDExt, count uint32, after ...*ton.TransactionID3) ([]ton.TransactionShortInfo, bool, error)) *MockAPIClientWrapped_GetBlockTransactionsV2_Call { + _c.Call.Return(run) + return _c +} + +// GetBlockchainConfig provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetBlockchainConfig(ctx context.Context, block *ton.BlockIDExt, onlyParams ...int32) (*ton.BlockchainConfig, error) { + var tmpRet mock.Arguments + if len(onlyParams) > 0 { + tmpRet = _mock.Called(ctx, block, onlyParams) + } else { + tmpRet = _mock.Called(ctx, block) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBlockchainConfig") + } + + var r0 *ton.BlockchainConfig + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, ...int32) (*ton.BlockchainConfig, error)); ok { + return returnFunc(ctx, block, onlyParams...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, ...int32) *ton.BlockchainConfig); ok { + r0 = returnFunc(ctx, block, onlyParams...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ton.BlockchainConfig) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *ton.BlockIDExt, ...int32) error); ok { + r1 = returnFunc(ctx, block, onlyParams...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_GetBlockchainConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlockchainConfig' +type MockAPIClientWrapped_GetBlockchainConfig_Call struct { + *mock.Call +} + +// GetBlockchainConfig is a helper method to define mock.On call +// - ctx context.Context +// - block *ton.BlockIDExt +// - onlyParams ...int32 +func (_e *MockAPIClientWrapped_Expecter) GetBlockchainConfig(ctx interface{}, block interface{}, onlyParams ...interface{}) *MockAPIClientWrapped_GetBlockchainConfig_Call { + return &MockAPIClientWrapped_GetBlockchainConfig_Call{Call: _e.mock.On("GetBlockchainConfig", + append([]interface{}{ctx, block}, onlyParams...)...)} +} + +func (_c *MockAPIClientWrapped_GetBlockchainConfig_Call) Run(run func(ctx context.Context, block *ton.BlockIDExt, onlyParams ...int32)) *MockAPIClientWrapped_GetBlockchainConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *ton.BlockIDExt + if args[1] != nil { + arg1 = args[1].(*ton.BlockIDExt) + } + var arg2 []int32 + var variadicArgs []int32 + if len(args) > 2 { + variadicArgs = args[2].([]int32) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_GetBlockchainConfig_Call) Return(blockchainConfig *ton.BlockchainConfig, err error) *MockAPIClientWrapped_GetBlockchainConfig_Call { + _c.Call.Return(blockchainConfig, err) + return _c +} + +func (_c *MockAPIClientWrapped_GetBlockchainConfig_Call) RunAndReturn(run func(ctx context.Context, block *ton.BlockIDExt, onlyParams ...int32) (*ton.BlockchainConfig, error)) *MockAPIClientWrapped_GetBlockchainConfig_Call { + _c.Call.Return(run) + return _c +} + +// GetLibraries provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetLibraries(ctx context.Context, list ...[]byte) ([]*cell.Cell, error) { + var tmpRet mock.Arguments + if len(list) > 0 { + tmpRet = _mock.Called(ctx, list) + } else { + tmpRet = _mock.Called(ctx) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetLibraries") + } + + var r0 []*cell.Cell + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, ...[]byte) ([]*cell.Cell, error)); ok { + return returnFunc(ctx, list...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, ...[]byte) []*cell.Cell); ok { + r0 = returnFunc(ctx, list...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*cell.Cell) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, ...[]byte) error); ok { + r1 = returnFunc(ctx, list...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_GetLibraries_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLibraries' +type MockAPIClientWrapped_GetLibraries_Call struct { + *mock.Call +} + +// GetLibraries is a helper method to define mock.On call +// - ctx context.Context +// - list ...[]byte +func (_e *MockAPIClientWrapped_Expecter) GetLibraries(ctx interface{}, list ...interface{}) *MockAPIClientWrapped_GetLibraries_Call { + return &MockAPIClientWrapped_GetLibraries_Call{Call: _e.mock.On("GetLibraries", + append([]interface{}{ctx}, list...)...)} +} + +func (_c *MockAPIClientWrapped_GetLibraries_Call) Run(run func(ctx context.Context, list ...[]byte)) *MockAPIClientWrapped_GetLibraries_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 [][]byte + var variadicArgs [][]byte + if len(args) > 1 { + variadicArgs = args[1].([][]byte) + } + arg1 = variadicArgs + run( + arg0, + arg1..., + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_GetLibraries_Call) Return(cells []*cell.Cell, err error) *MockAPIClientWrapped_GetLibraries_Call { + _c.Call.Return(cells, err) + return _c +} + +func (_c *MockAPIClientWrapped_GetLibraries_Call) RunAndReturn(run func(ctx context.Context, list ...[]byte) ([]*cell.Cell, error)) *MockAPIClientWrapped_GetLibraries_Call { + _c.Call.Return(run) + return _c +} + +// GetMasterchainInfo provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetMasterchainInfo(ctx context.Context) (*ton.BlockIDExt, error) { + ret := _mock.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for GetMasterchainInfo") + } + + var r0 *ton.BlockIDExt + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context) (*ton.BlockIDExt, error)); ok { + return returnFunc(ctx) + } + if returnFunc, ok := ret.Get(0).(func(context.Context) *ton.BlockIDExt); ok { + r0 = returnFunc(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ton.BlockIDExt) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = returnFunc(ctx) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_GetMasterchainInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMasterchainInfo' +type MockAPIClientWrapped_GetMasterchainInfo_Call struct { + *mock.Call +} + +// GetMasterchainInfo is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockAPIClientWrapped_Expecter) GetMasterchainInfo(ctx interface{}) *MockAPIClientWrapped_GetMasterchainInfo_Call { + return &MockAPIClientWrapped_GetMasterchainInfo_Call{Call: _e.mock.On("GetMasterchainInfo", ctx)} +} + +func (_c *MockAPIClientWrapped_GetMasterchainInfo_Call) Run(run func(ctx context.Context)) *MockAPIClientWrapped_GetMasterchainInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_GetMasterchainInfo_Call) Return(v *ton.BlockIDExt, err error) *MockAPIClientWrapped_GetMasterchainInfo_Call { + _c.Call.Return(v, err) + return _c +} + +func (_c *MockAPIClientWrapped_GetMasterchainInfo_Call) RunAndReturn(run func(ctx context.Context) (*ton.BlockIDExt, error)) *MockAPIClientWrapped_GetMasterchainInfo_Call { + _c.Call.Return(run) + return _c +} + +// GetTime provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetTime(ctx context.Context) (uint32, error) { + ret := _mock.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for GetTime") + } + + var r0 uint32 + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context) (uint32, error)); ok { + return returnFunc(ctx) + } + if returnFunc, ok := ret.Get(0).(func(context.Context) uint32); ok { + r0 = returnFunc(ctx) + } else { + r0 = ret.Get(0).(uint32) + } + if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = returnFunc(ctx) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_GetTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTime' +type MockAPIClientWrapped_GetTime_Call struct { + *mock.Call +} + +// GetTime is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockAPIClientWrapped_Expecter) GetTime(ctx interface{}) *MockAPIClientWrapped_GetTime_Call { + return &MockAPIClientWrapped_GetTime_Call{Call: _e.mock.On("GetTime", ctx)} +} + +func (_c *MockAPIClientWrapped_GetTime_Call) Run(run func(ctx context.Context)) *MockAPIClientWrapped_GetTime_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_GetTime_Call) Return(v uint32, err error) *MockAPIClientWrapped_GetTime_Call { + _c.Call.Return(v, err) + return _c +} + +func (_c *MockAPIClientWrapped_GetTime_Call) RunAndReturn(run func(ctx context.Context) (uint32, error)) *MockAPIClientWrapped_GetTime_Call { + _c.Call.Return(run) + return _c +} + +// GetTransaction provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetTransaction(ctx context.Context, block *ton.BlockIDExt, addr *address.Address, lt uint64) (*tlb.Transaction, error) { + ret := _mock.Called(ctx, block, addr, lt) + + if len(ret) == 0 { + panic("no return value specified for GetTransaction") + } + + var r0 *tlb.Transaction + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, *address.Address, uint64) (*tlb.Transaction, error)); ok { + return returnFunc(ctx, block, addr, lt) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, *address.Address, uint64) *tlb.Transaction); ok { + r0 = returnFunc(ctx, block, addr, lt) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*tlb.Transaction) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *ton.BlockIDExt, *address.Address, uint64) error); ok { + r1 = returnFunc(ctx, block, addr, lt) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_GetTransaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTransaction' +type MockAPIClientWrapped_GetTransaction_Call struct { + *mock.Call +} + +// GetTransaction is a helper method to define mock.On call +// - ctx context.Context +// - block *ton.BlockIDExt +// - addr *address.Address +// - lt uint64 +func (_e *MockAPIClientWrapped_Expecter) GetTransaction(ctx interface{}, block interface{}, addr interface{}, lt interface{}) *MockAPIClientWrapped_GetTransaction_Call { + return &MockAPIClientWrapped_GetTransaction_Call{Call: _e.mock.On("GetTransaction", ctx, block, addr, lt)} +} + +func (_c *MockAPIClientWrapped_GetTransaction_Call) Run(run func(ctx context.Context, block *ton.BlockIDExt, addr *address.Address, lt uint64)) *MockAPIClientWrapped_GetTransaction_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *ton.BlockIDExt + if args[1] != nil { + arg1 = args[1].(*ton.BlockIDExt) + } + var arg2 *address.Address + if args[2] != nil { + arg2 = args[2].(*address.Address) + } + var arg3 uint64 + if args[3] != nil { + arg3 = args[3].(uint64) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_GetTransaction_Call) Return(transaction *tlb.Transaction, err error) *MockAPIClientWrapped_GetTransaction_Call { + _c.Call.Return(transaction, err) + return _c +} + +func (_c *MockAPIClientWrapped_GetTransaction_Call) RunAndReturn(run func(ctx context.Context, block *ton.BlockIDExt, addr *address.Address, lt uint64) (*tlb.Transaction, error)) *MockAPIClientWrapped_GetTransaction_Call { + _c.Call.Return(run) + return _c +} + +// ListTransactions provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) ListTransactions(ctx context.Context, addr *address.Address, num uint32, lt uint64, txHash []byte) ([]*tlb.Transaction, error) { + ret := _mock.Called(ctx, addr, num, lt, txHash) + + if len(ret) == 0 { + panic("no return value specified for ListTransactions") + } + + var r0 []*tlb.Transaction + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *address.Address, uint32, uint64, []byte) ([]*tlb.Transaction, error)); ok { + return returnFunc(ctx, addr, num, lt, txHash) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *address.Address, uint32, uint64, []byte) []*tlb.Transaction); ok { + r0 = returnFunc(ctx, addr, num, lt, txHash) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*tlb.Transaction) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *address.Address, uint32, uint64, []byte) error); ok { + r1 = returnFunc(ctx, addr, num, lt, txHash) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_ListTransactions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTransactions' +type MockAPIClientWrapped_ListTransactions_Call struct { + *mock.Call +} + +// ListTransactions is a helper method to define mock.On call +// - ctx context.Context +// - addr *address.Address +// - num uint32 +// - lt uint64 +// - txHash []byte +func (_e *MockAPIClientWrapped_Expecter) ListTransactions(ctx interface{}, addr interface{}, num interface{}, lt interface{}, txHash interface{}) *MockAPIClientWrapped_ListTransactions_Call { + return &MockAPIClientWrapped_ListTransactions_Call{Call: _e.mock.On("ListTransactions", ctx, addr, num, lt, txHash)} +} + +func (_c *MockAPIClientWrapped_ListTransactions_Call) Run(run func(ctx context.Context, addr *address.Address, num uint32, lt uint64, txHash []byte)) *MockAPIClientWrapped_ListTransactions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *address.Address + if args[1] != nil { + arg1 = args[1].(*address.Address) + } + var arg2 uint32 + if args[2] != nil { + arg2 = args[2].(uint32) + } + var arg3 uint64 + if args[3] != nil { + arg3 = args[3].(uint64) + } + var arg4 []byte + if args[4] != nil { + arg4 = args[4].([]byte) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_ListTransactions_Call) Return(transactions []*tlb.Transaction, err error) *MockAPIClientWrapped_ListTransactions_Call { + _c.Call.Return(transactions, err) + return _c +} + +func (_c *MockAPIClientWrapped_ListTransactions_Call) RunAndReturn(run func(ctx context.Context, addr *address.Address, num uint32, lt uint64, txHash []byte) ([]*tlb.Transaction, error)) *MockAPIClientWrapped_ListTransactions_Call { + _c.Call.Return(run) + return _c +} + +// LookupBlock provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) LookupBlock(ctx context.Context, workchain int32, shard int64, seqno uint32) (*ton.BlockIDExt, error) { + ret := _mock.Called(ctx, workchain, shard, seqno) + + if len(ret) == 0 { + panic("no return value specified for LookupBlock") + } + + var r0 *ton.BlockIDExt + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, int32, int64, uint32) (*ton.BlockIDExt, error)); ok { + return returnFunc(ctx, workchain, shard, seqno) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, int32, int64, uint32) *ton.BlockIDExt); ok { + r0 = returnFunc(ctx, workchain, shard, seqno) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ton.BlockIDExt) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, int32, int64, uint32) error); ok { + r1 = returnFunc(ctx, workchain, shard, seqno) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_LookupBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LookupBlock' +type MockAPIClientWrapped_LookupBlock_Call struct { + *mock.Call +} + +// LookupBlock is a helper method to define mock.On call +// - ctx context.Context +// - workchain int32 +// - shard int64 +// - seqno uint32 +func (_e *MockAPIClientWrapped_Expecter) LookupBlock(ctx interface{}, workchain interface{}, shard interface{}, seqno interface{}) *MockAPIClientWrapped_LookupBlock_Call { + return &MockAPIClientWrapped_LookupBlock_Call{Call: _e.mock.On("LookupBlock", ctx, workchain, shard, seqno)} +} + +func (_c *MockAPIClientWrapped_LookupBlock_Call) Run(run func(ctx context.Context, workchain int32, shard int64, seqno uint32)) *MockAPIClientWrapped_LookupBlock_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 int32 + if args[1] != nil { + arg1 = args[1].(int32) + } + var arg2 int64 + if args[2] != nil { + arg2 = args[2].(int64) + } + var arg3 uint32 + if args[3] != nil { + arg3 = args[3].(uint32) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_LookupBlock_Call) Return(v *ton.BlockIDExt, err error) *MockAPIClientWrapped_LookupBlock_Call { + _c.Call.Return(v, err) + return _c +} + +func (_c *MockAPIClientWrapped_LookupBlock_Call) RunAndReturn(run func(ctx context.Context, workchain int32, shard int64, seqno uint32) (*ton.BlockIDExt, error)) *MockAPIClientWrapped_LookupBlock_Call { + _c.Call.Return(run) + return _c +} + +// RunGetMethod provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) RunGetMethod(ctx context.Context, blockInfo *ton.BlockIDExt, addr *address.Address, method string, params ...interface{}) (*ton.ExecutionResult, error) { + var tmpRet mock.Arguments + if len(params) > 0 { + tmpRet = _mock.Called(ctx, blockInfo, addr, method, params) + } else { + tmpRet = _mock.Called(ctx, blockInfo, addr, method) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for RunGetMethod") + } + + var r0 *ton.ExecutionResult + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, *address.Address, string, ...interface{}) (*ton.ExecutionResult, error)); ok { + return returnFunc(ctx, blockInfo, addr, method, params...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, *address.Address, string, ...interface{}) *ton.ExecutionResult); ok { + r0 = returnFunc(ctx, blockInfo, addr, method, params...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ton.ExecutionResult) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *ton.BlockIDExt, *address.Address, string, ...interface{}) error); ok { + r1 = returnFunc(ctx, blockInfo, addr, method, params...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_RunGetMethod_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunGetMethod' +type MockAPIClientWrapped_RunGetMethod_Call struct { + *mock.Call +} + +// RunGetMethod is a helper method to define mock.On call +// - ctx context.Context +// - blockInfo *ton.BlockIDExt +// - addr *address.Address +// - method string +// - params ...interface{} +func (_e *MockAPIClientWrapped_Expecter) RunGetMethod(ctx interface{}, blockInfo interface{}, addr interface{}, method interface{}, params ...interface{}) *MockAPIClientWrapped_RunGetMethod_Call { + return &MockAPIClientWrapped_RunGetMethod_Call{Call: _e.mock.On("RunGetMethod", + append([]interface{}{ctx, blockInfo, addr, method}, params...)...)} +} + +func (_c *MockAPIClientWrapped_RunGetMethod_Call) Run(run func(ctx context.Context, blockInfo *ton.BlockIDExt, addr *address.Address, method string, params ...interface{})) *MockAPIClientWrapped_RunGetMethod_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *ton.BlockIDExt + if args[1] != nil { + arg1 = args[1].(*ton.BlockIDExt) + } + var arg2 *address.Address + if args[2] != nil { + arg2 = args[2].(*address.Address) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + var arg4 []interface{} + var variadicArgs []interface{} + if len(args) > 4 { + variadicArgs = args[4].([]interface{}) + } + arg4 = variadicArgs + run( + arg0, + arg1, + arg2, + arg3, + arg4..., + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_RunGetMethod_Call) Return(executionResult *ton.ExecutionResult, err error) *MockAPIClientWrapped_RunGetMethod_Call { + _c.Call.Return(executionResult, err) + return _c +} + +func (_c *MockAPIClientWrapped_RunGetMethod_Call) RunAndReturn(run func(ctx context.Context, blockInfo *ton.BlockIDExt, addr *address.Address, method string, params ...interface{}) (*ton.ExecutionResult, error)) *MockAPIClientWrapped_RunGetMethod_Call { + _c.Call.Return(run) + return _c +} + +// SendExternalMessage provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) SendExternalMessage(ctx context.Context, msg *tlb.ExternalMessage) error { + ret := _mock.Called(ctx, msg) + + if len(ret) == 0 { + panic("no return value specified for SendExternalMessage") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *tlb.ExternalMessage) error); ok { + r0 = returnFunc(ctx, msg) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// MockAPIClientWrapped_SendExternalMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendExternalMessage' +type MockAPIClientWrapped_SendExternalMessage_Call struct { + *mock.Call +} + +// SendExternalMessage is a helper method to define mock.On call +// - ctx context.Context +// - msg *tlb.ExternalMessage +func (_e *MockAPIClientWrapped_Expecter) SendExternalMessage(ctx interface{}, msg interface{}) *MockAPIClientWrapped_SendExternalMessage_Call { + return &MockAPIClientWrapped_SendExternalMessage_Call{Call: _e.mock.On("SendExternalMessage", ctx, msg)} +} + +func (_c *MockAPIClientWrapped_SendExternalMessage_Call) Run(run func(ctx context.Context, msg *tlb.ExternalMessage)) *MockAPIClientWrapped_SendExternalMessage_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *tlb.ExternalMessage + if args[1] != nil { + arg1 = args[1].(*tlb.ExternalMessage) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_SendExternalMessage_Call) Return(err error) *MockAPIClientWrapped_SendExternalMessage_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockAPIClientWrapped_SendExternalMessage_Call) RunAndReturn(run func(ctx context.Context, msg *tlb.ExternalMessage) error) *MockAPIClientWrapped_SendExternalMessage_Call { + _c.Call.Return(run) + return _c +} + +// SendExternalMessageWaitTransaction provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) SendExternalMessageWaitTransaction(ctx context.Context, msg *tlb.ExternalMessage) (*tlb.Transaction, *ton.BlockIDExt, []byte, error) { + ret := _mock.Called(ctx, msg) + + if len(ret) == 0 { + panic("no return value specified for SendExternalMessageWaitTransaction") + } + + var r0 *tlb.Transaction + var r1 *ton.BlockIDExt + var r2 []byte + var r3 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *tlb.ExternalMessage) (*tlb.Transaction, *ton.BlockIDExt, []byte, error)); ok { + return returnFunc(ctx, msg) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *tlb.ExternalMessage) *tlb.Transaction); ok { + r0 = returnFunc(ctx, msg) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*tlb.Transaction) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *tlb.ExternalMessage) *ton.BlockIDExt); ok { + r1 = returnFunc(ctx, msg) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(*ton.BlockIDExt) + } + } + if returnFunc, ok := ret.Get(2).(func(context.Context, *tlb.ExternalMessage) []byte); ok { + r2 = returnFunc(ctx, msg) + } else { + if ret.Get(2) != nil { + r2 = ret.Get(2).([]byte) + } + } + if returnFunc, ok := ret.Get(3).(func(context.Context, *tlb.ExternalMessage) error); ok { + r3 = returnFunc(ctx, msg) + } else { + r3 = ret.Error(3) + } + return r0, r1, r2, r3 +} + +// MockAPIClientWrapped_SendExternalMessageWaitTransaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendExternalMessageWaitTransaction' +type MockAPIClientWrapped_SendExternalMessageWaitTransaction_Call struct { + *mock.Call +} + +// SendExternalMessageWaitTransaction is a helper method to define mock.On call +// - ctx context.Context +// - msg *tlb.ExternalMessage +func (_e *MockAPIClientWrapped_Expecter) SendExternalMessageWaitTransaction(ctx interface{}, msg interface{}) *MockAPIClientWrapped_SendExternalMessageWaitTransaction_Call { + return &MockAPIClientWrapped_SendExternalMessageWaitTransaction_Call{Call: _e.mock.On("SendExternalMessageWaitTransaction", ctx, msg)} +} + +func (_c *MockAPIClientWrapped_SendExternalMessageWaitTransaction_Call) Run(run func(ctx context.Context, msg *tlb.ExternalMessage)) *MockAPIClientWrapped_SendExternalMessageWaitTransaction_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *tlb.ExternalMessage + if args[1] != nil { + arg1 = args[1].(*tlb.ExternalMessage) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_SendExternalMessageWaitTransaction_Call) Return(transaction *tlb.Transaction, v *ton.BlockIDExt, bytes []byte, err error) *MockAPIClientWrapped_SendExternalMessageWaitTransaction_Call { + _c.Call.Return(transaction, v, bytes, err) + return _c +} + +func (_c *MockAPIClientWrapped_SendExternalMessageWaitTransaction_Call) RunAndReturn(run func(ctx context.Context, msg *tlb.ExternalMessage) (*tlb.Transaction, *ton.BlockIDExt, []byte, error)) *MockAPIClientWrapped_SendExternalMessageWaitTransaction_Call { + _c.Call.Return(run) + return _c +} + +// SetTrustedBlock provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) SetTrustedBlock(block *ton.BlockIDExt) { + _mock.Called(block) + return +} + +// MockAPIClientWrapped_SetTrustedBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrustedBlock' +type MockAPIClientWrapped_SetTrustedBlock_Call struct { + *mock.Call +} + +// SetTrustedBlock is a helper method to define mock.On call +// - block *ton.BlockIDExt +func (_e *MockAPIClientWrapped_Expecter) SetTrustedBlock(block interface{}) *MockAPIClientWrapped_SetTrustedBlock_Call { + return &MockAPIClientWrapped_SetTrustedBlock_Call{Call: _e.mock.On("SetTrustedBlock", block)} +} + +func (_c *MockAPIClientWrapped_SetTrustedBlock_Call) Run(run func(block *ton.BlockIDExt)) *MockAPIClientWrapped_SetTrustedBlock_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *ton.BlockIDExt + if args[0] != nil { + arg0 = args[0].(*ton.BlockIDExt) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_SetTrustedBlock_Call) Return() *MockAPIClientWrapped_SetTrustedBlock_Call { + _c.Call.Return() + return _c +} + +func (_c *MockAPIClientWrapped_SetTrustedBlock_Call) RunAndReturn(run func(block *ton.BlockIDExt)) *MockAPIClientWrapped_SetTrustedBlock_Call { + _c.Run(run) + return _c +} + +// SetTrustedBlockFromConfig provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) SetTrustedBlockFromConfig(cfg *liteclient.GlobalConfig) { + _mock.Called(cfg) + return +} + +// MockAPIClientWrapped_SetTrustedBlockFromConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTrustedBlockFromConfig' +type MockAPIClientWrapped_SetTrustedBlockFromConfig_Call struct { + *mock.Call +} + +// SetTrustedBlockFromConfig is a helper method to define mock.On call +// - cfg *liteclient.GlobalConfig +func (_e *MockAPIClientWrapped_Expecter) SetTrustedBlockFromConfig(cfg interface{}) *MockAPIClientWrapped_SetTrustedBlockFromConfig_Call { + return &MockAPIClientWrapped_SetTrustedBlockFromConfig_Call{Call: _e.mock.On("SetTrustedBlockFromConfig", cfg)} +} + +func (_c *MockAPIClientWrapped_SetTrustedBlockFromConfig_Call) Run(run func(cfg *liteclient.GlobalConfig)) *MockAPIClientWrapped_SetTrustedBlockFromConfig_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *liteclient.GlobalConfig + if args[0] != nil { + arg0 = args[0].(*liteclient.GlobalConfig) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_SetTrustedBlockFromConfig_Call) Return() *MockAPIClientWrapped_SetTrustedBlockFromConfig_Call { + _c.Call.Return() + return _c +} + +func (_c *MockAPIClientWrapped_SetTrustedBlockFromConfig_Call) RunAndReturn(run func(cfg *liteclient.GlobalConfig)) *MockAPIClientWrapped_SetTrustedBlockFromConfig_Call { + _c.Run(run) + return _c +} + +// SubscribeOnTransactions provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) SubscribeOnTransactions(workerCtx context.Context, addr *address.Address, lastProcessedLT uint64, channel chan<- *tlb.Transaction) { + _mock.Called(workerCtx, addr, lastProcessedLT, channel) + return +} + +// MockAPIClientWrapped_SubscribeOnTransactions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribeOnTransactions' +type MockAPIClientWrapped_SubscribeOnTransactions_Call struct { + *mock.Call +} + +// SubscribeOnTransactions is a helper method to define mock.On call +// - workerCtx context.Context +// - addr *address.Address +// - lastProcessedLT uint64 +// - channel chan<- *tlb.Transaction +func (_e *MockAPIClientWrapped_Expecter) SubscribeOnTransactions(workerCtx interface{}, addr interface{}, lastProcessedLT interface{}, channel interface{}) *MockAPIClientWrapped_SubscribeOnTransactions_Call { + return &MockAPIClientWrapped_SubscribeOnTransactions_Call{Call: _e.mock.On("SubscribeOnTransactions", workerCtx, addr, lastProcessedLT, channel)} +} + +func (_c *MockAPIClientWrapped_SubscribeOnTransactions_Call) Run(run func(workerCtx context.Context, addr *address.Address, lastProcessedLT uint64, channel chan<- *tlb.Transaction)) *MockAPIClientWrapped_SubscribeOnTransactions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *address.Address + if args[1] != nil { + arg1 = args[1].(*address.Address) + } + var arg2 uint64 + if args[2] != nil { + arg2 = args[2].(uint64) + } + var arg3 chan<- *tlb.Transaction + if args[3] != nil { + arg3 = args[3].(chan<- *tlb.Transaction) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_SubscribeOnTransactions_Call) Return() *MockAPIClientWrapped_SubscribeOnTransactions_Call { + _c.Call.Return() + return _c +} + +func (_c *MockAPIClientWrapped_SubscribeOnTransactions_Call) RunAndReturn(run func(workerCtx context.Context, addr *address.Address, lastProcessedLT uint64, channel chan<- *tlb.Transaction)) *MockAPIClientWrapped_SubscribeOnTransactions_Call { + _c.Run(run) + return _c +} + +// VerifyProofChain provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) VerifyProofChain(ctx context.Context, from *ton.BlockIDExt, to *ton.BlockIDExt) error { + ret := _mock.Called(ctx, from, to) + + if len(ret) == 0 { + panic("no return value specified for VerifyProofChain") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, *ton.BlockIDExt) error); ok { + r0 = returnFunc(ctx, from, to) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// MockAPIClientWrapped_VerifyProofChain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VerifyProofChain' +type MockAPIClientWrapped_VerifyProofChain_Call struct { + *mock.Call +} + +// VerifyProofChain is a helper method to define mock.On call +// - ctx context.Context +// - from *ton.BlockIDExt +// - to *ton.BlockIDExt +func (_e *MockAPIClientWrapped_Expecter) VerifyProofChain(ctx interface{}, from interface{}, to interface{}) *MockAPIClientWrapped_VerifyProofChain_Call { + return &MockAPIClientWrapped_VerifyProofChain_Call{Call: _e.mock.On("VerifyProofChain", ctx, from, to)} +} + +func (_c *MockAPIClientWrapped_VerifyProofChain_Call) Run(run func(ctx context.Context, from *ton.BlockIDExt, to *ton.BlockIDExt)) *MockAPIClientWrapped_VerifyProofChain_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *ton.BlockIDExt + if args[1] != nil { + arg1 = args[1].(*ton.BlockIDExt) + } + var arg2 *ton.BlockIDExt + if args[2] != nil { + arg2 = args[2].(*ton.BlockIDExt) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_VerifyProofChain_Call) Return(err error) *MockAPIClientWrapped_VerifyProofChain_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockAPIClientWrapped_VerifyProofChain_Call) RunAndReturn(run func(ctx context.Context, from *ton.BlockIDExt, to *ton.BlockIDExt) error) *MockAPIClientWrapped_VerifyProofChain_Call { + _c.Call.Return(run) + return _c +} + +// WaitForBlock provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) WaitForBlock(seqno uint32) ton.APIClientWrapped { + ret := _mock.Called(seqno) + + if len(ret) == 0 { + panic("no return value specified for WaitForBlock") + } + + var r0 ton.APIClientWrapped + if returnFunc, ok := ret.Get(0).(func(uint32) ton.APIClientWrapped); ok { + r0 = returnFunc(seqno) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(ton.APIClientWrapped) + } + } + return r0 +} + +// MockAPIClientWrapped_WaitForBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitForBlock' +type MockAPIClientWrapped_WaitForBlock_Call struct { + *mock.Call +} + +// WaitForBlock is a helper method to define mock.On call +// - seqno uint32 +func (_e *MockAPIClientWrapped_Expecter) WaitForBlock(seqno interface{}) *MockAPIClientWrapped_WaitForBlock_Call { + return &MockAPIClientWrapped_WaitForBlock_Call{Call: _e.mock.On("WaitForBlock", seqno)} +} + +func (_c *MockAPIClientWrapped_WaitForBlock_Call) Run(run func(seqno uint32)) *MockAPIClientWrapped_WaitForBlock_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 uint32 + if args[0] != nil { + arg0 = args[0].(uint32) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_WaitForBlock_Call) Return(aPIClientWrapped ton.APIClientWrapped) *MockAPIClientWrapped_WaitForBlock_Call { + _c.Call.Return(aPIClientWrapped) + return _c +} + +func (_c *MockAPIClientWrapped_WaitForBlock_Call) RunAndReturn(run func(seqno uint32) ton.APIClientWrapped) *MockAPIClientWrapped_WaitForBlock_Call { + _c.Call.Return(run) + return _c +} + +// WithRetry provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) WithRetry(maxRetries ...int) ton.APIClientWrapped { + var tmpRet mock.Arguments + if len(maxRetries) > 0 { + tmpRet = _mock.Called(maxRetries) + } else { + tmpRet = _mock.Called() + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for WithRetry") + } + + var r0 ton.APIClientWrapped + if returnFunc, ok := ret.Get(0).(func(...int) ton.APIClientWrapped); ok { + r0 = returnFunc(maxRetries...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(ton.APIClientWrapped) + } + } + return r0 +} + +// MockAPIClientWrapped_WithRetry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithRetry' +type MockAPIClientWrapped_WithRetry_Call struct { + *mock.Call +} + +// WithRetry is a helper method to define mock.On call +// - maxRetries ...int +func (_e *MockAPIClientWrapped_Expecter) WithRetry(maxRetries ...interface{}) *MockAPIClientWrapped_WithRetry_Call { + return &MockAPIClientWrapped_WithRetry_Call{Call: _e.mock.On("WithRetry", + append([]interface{}{}, maxRetries...)...)} +} + +func (_c *MockAPIClientWrapped_WithRetry_Call) Run(run func(maxRetries ...int)) *MockAPIClientWrapped_WithRetry_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 []int + var variadicArgs []int + if len(args) > 0 { + variadicArgs = args[0].([]int) + } + arg0 = variadicArgs + run( + arg0..., + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_WithRetry_Call) Return(aPIClientWrapped ton.APIClientWrapped) *MockAPIClientWrapped_WithRetry_Call { + _c.Call.Return(aPIClientWrapped) + return _c +} + +func (_c *MockAPIClientWrapped_WithRetry_Call) RunAndReturn(run func(maxRetries ...int) ton.APIClientWrapped) *MockAPIClientWrapped_WithRetry_Call { + _c.Call.Return(run) + return _c +} + +// WithTimeout provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) WithTimeout(timeout time.Duration) ton.APIClientWrapped { + ret := _mock.Called(timeout) + + if len(ret) == 0 { + panic("no return value specified for WithTimeout") + } + + var r0 ton.APIClientWrapped + if returnFunc, ok := ret.Get(0).(func(time.Duration) ton.APIClientWrapped); ok { + r0 = returnFunc(timeout) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(ton.APIClientWrapped) + } + } + return r0 +} + +// MockAPIClientWrapped_WithTimeout_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithTimeout' +type MockAPIClientWrapped_WithTimeout_Call struct { + *mock.Call +} + +// WithTimeout is a helper method to define mock.On call +// - timeout time.Duration +func (_e *MockAPIClientWrapped_Expecter) WithTimeout(timeout interface{}) *MockAPIClientWrapped_WithTimeout_Call { + return &MockAPIClientWrapped_WithTimeout_Call{Call: _e.mock.On("WithTimeout", timeout)} +} + +func (_c *MockAPIClientWrapped_WithTimeout_Call) Run(run func(timeout time.Duration)) *MockAPIClientWrapped_WithTimeout_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 time.Duration + if args[0] != nil { + arg0 = args[0].(time.Duration) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_WithTimeout_Call) Return(aPIClientWrapped ton.APIClientWrapped) *MockAPIClientWrapped_WithTimeout_Call { + _c.Call.Return(aPIClientWrapped) + return _c +} + +func (_c *MockAPIClientWrapped_WithTimeout_Call) RunAndReturn(run func(timeout time.Duration) ton.APIClientWrapped) *MockAPIClientWrapped_WithTimeout_Call { + _c.Call.Return(run) + return _c +} diff --git a/go.mod b/go.mod index f9dade0a3..35c2c5671 100644 --- a/go.mod +++ b/go.mod @@ -41,7 +41,7 @@ require ( github.com/smartcontractkit/chainlink-tron/relayer v0.0.11-0.20250815105909-75499abc4335 github.com/smartcontractkit/freeport v0.1.3-0.20250828155247-add56fa28aad github.com/smartcontractkit/libocr v0.0.0-20250912173940-f3ab0246e23d - github.com/smartcontractkit/mcms v0.36.4 + github.com/smartcontractkit/mcms v0.37.0 github.com/spf13/cobra v1.10.2 github.com/spf13/pflag v1.0.10 github.com/spf13/viper v1.21.0 diff --git a/go.sum b/go.sum index 88c0dd835..5fabdf508 100644 --- a/go.sum +++ b/go.sum @@ -787,8 +787,8 @@ github.com/smartcontractkit/grpc-proxy v0.0.0-20240830132753-a7e17fec5ab7 h1:12i github.com/smartcontractkit/grpc-proxy v0.0.0-20240830132753-a7e17fec5ab7/go.mod h1:FX7/bVdoep147QQhsOPkYsPEXhGZjeYx6lBSaSXtZOA= github.com/smartcontractkit/libocr v0.0.0-20250912173940-f3ab0246e23d h1:LokA9PoCNb8mm8mDT52c3RECPMRsGz1eCQORq+J3n74= github.com/smartcontractkit/libocr v0.0.0-20250912173940-f3ab0246e23d/go.mod h1:Acy3BTBxou83ooMESLO90s8PKSu7RvLCzwSTbxxfOK0= -github.com/smartcontractkit/mcms v0.36.4 h1:7WJZVa9txg6RiVznaKybPIbxwq4OBSjVUSEW9bMFNA8= -github.com/smartcontractkit/mcms v0.36.4/go.mod h1:7YqJPR8w9GiO1L/JjjTrwlSwAZ7i3J7cgOcu88PqtvU= +github.com/smartcontractkit/mcms v0.37.0 h1:h3tqQhVdLezyHOuPsGcknPFLlZlXpOHTchwlfO3D9s8= +github.com/smartcontractkit/mcms v0.37.0/go.mod h1:7YqJPR8w9GiO1L/JjjTrwlSwAZ7i3J7cgOcu88PqtvU= github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 h1:+jumHNA0Wrelhe64i8F6HNlS8pkoyMv5sreGx2Ry5Rw= github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8/go.mod h1:3n1Cwaq1E1/1lhQhtRK2ts/ZwZEhjcQeJQ1RuC6Q/8U= github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=