From 2a73105210279b0d16c726d3123ea744aff63909 Mon Sep 17 00:00:00 2001 From: Patricio Tourne Passarino Date: Fri, 17 Jul 2026 15:54:36 -0300 Subject: [PATCH 1/2] wip: bump github.com/xssnick/tonutils-go --- chain/ton/mocks/api_client_wrapped.go | 2 ++ chain/ton/provider/ctf_provider.go | 5 +++-- chain/ton/provider/rpc_provider.go | 2 +- chain/ton/ton_chain.go | 2 +- chain/ton/ton_chain_test.go | 4 ++-- go.mod | 8 ++++---- go.sum | 18 ++++++++---------- 7 files changed, 21 insertions(+), 20 deletions(-) diff --git a/chain/ton/mocks/api_client_wrapped.go b/chain/ton/mocks/api_client_wrapped.go index b671fe0fe..d160a9309 100644 --- a/chain/ton/mocks/api_client_wrapped.go +++ b/chain/ton/mocks/api_client_wrapped.go @@ -30,6 +30,8 @@ func NewMockAPIClientWrapped(t interface { return mock } +var _ ton.APIClientWrapped = (*MockAPIClientWrapped)(nil) + // MockAPIClientWrapped is an autogenerated mock type for the APIClientWrapped type type MockAPIClientWrapped struct { mock.Mock diff --git a/chain/ton/provider/ctf_provider.go b/chain/ton/provider/ctf_provider.go index 2fb7fe6ad..4058c98eb 100644 --- a/chain/ton/provider/ctf_provider.go +++ b/chain/ton/provider/ctf_provider.go @@ -17,9 +17,10 @@ import ( "github.com/xssnick/tonutils-go/ton/wallet" chainsel "github.com/smartcontractkit/chain-selectors" + "github.com/smartcontractkit/freeport" + "github.com/smartcontractkit/chainlink-testing-framework/framework" "github.com/smartcontractkit/chainlink-testing-framework/framework/components/blockchain" - "github.com/smartcontractkit/freeport" "github.com/smartcontractkit/chainlink-deployments-framework/chain" cldf_ton "github.com/smartcontractkit/chainlink-deployments-framework/chain/ton" @@ -217,7 +218,7 @@ func createTonWallet(client ton.APIClientWrapped, versionConfig wallet.VersionCo if err != nil { return nil, fmt.Errorf("failed to create wallet from seed: %w", err) } - pw, perr := wallet.FromPrivateKeyWithOptions(client, rw.PrivateKey(), versionConfig, option) + pw, perr := wallet.FromPrivateKeyWithOptions(rw.PrivateKey(), versionConfig, wallet.WithAPI(client), option) if perr != nil { return nil, fmt.Errorf("failed to create wallet from private key: %w", perr) } diff --git a/chain/ton/provider/rpc_provider.go b/chain/ton/provider/rpc_provider.go index efea3c695..4e190ec71 100644 --- a/chain/ton/provider/rpc_provider.go +++ b/chain/ton/provider/rpc_provider.go @@ -139,7 +139,7 @@ func createWallet( return nil, nil, fmt.Errorf("unsupported wallet version: %w", err) } - tonWallet, err := wallet.FromPrivateKeyWithOptions(api, privateKey, walletConfig, wallet.WithWorkchain(0)) + tonWallet, err := wallet.FromPrivateKeyWithOptions(privateKey, walletConfig, wallet.WithAPI(api), wallet.WithWorkchain(0)) if err != nil { return nil, nil, fmt.Errorf("failed to init TON wallet: %w", err) } diff --git a/chain/ton/ton_chain.go b/chain/ton/ton_chain.go index 9d55eaf5f..628c49a9c 100644 --- a/chain/ton/ton_chain.go +++ b/chain/ton/ton_chain.go @@ -46,7 +46,7 @@ func (c Chain) ReadOnly() (common.BlockChain, error) { return nil, fmt.Errorf("failed to generate private key for read-only chain %v: %w", c, err) } - c.Wallet, err = wallet.FromPrivateKeyWithOptions(c.Client, privateKey, c.WalletVersionConfig) + c.Wallet, err = wallet.FromPrivateKeyWithOptions(privateKey, c.WalletVersionConfig, wallet.WithAPI(c.Client)) if err != nil { return nil, fmt.Errorf("failed to generate wallet for read-only chain %v: %w", c, err) } diff --git a/chain/ton/ton_chain_test.go b/chain/ton/ton_chain_test.go index 5437f697a..84b6ca5eb 100644 --- a/chain/ton/ton_chain_test.go +++ b/chain/ton/ton_chain_test.go @@ -105,8 +105,8 @@ func funder(t *testing.T, tonChain ton.Chain) *wallet.Wallet { t.Helper() funderWallet, err := wallet.FromSeed(tonChain.Client, strings.Fields(faucetMnemonic), wallet.HighloadV2Verified) //nolint:staticcheck require.NoError(t, err) - funderWallet, err = wallet.FromPrivateKeyWithOptions(tonChain.Client, funderWallet.PrivateKey(), - wallet.HighloadV2Verified, wallet.WithWorkchain(int8(address.MasterchainID))) //nolint:staticcheck + funderWallet, err = wallet.FromPrivateKeyWithOptions(funderWallet.PrivateKey(), + wallet.HighloadV2Verified, wallet.WithAPI(tonChain.Client), wallet.WithWorkchain(int8(address.MasterchainID))) //nolint:staticcheck require.NoError(t, err) funder, err := funderWallet.GetSubwallet(uint32(42)) require.NoError(t, err) diff --git a/go.mod b/go.mod index 22f34b6c8..916fd9541 100644 --- a/go.mod +++ b/go.mod @@ -57,7 +57,7 @@ require ( github.com/stretchr/testify v1.11.1 github.com/testcontainers/testcontainers-go v0.43.0 github.com/testcontainers/testcontainers-go/modules/postgres v0.43.0 - github.com/xssnick/tonutils-go v1.14.1 + github.com/xssnick/tonutils-go v1.18.0 github.com/zksync-sdk/zksync2-go v1.1.1-0.20250620124214-2c742ee399c6 go.uber.org/zap v1.28.0 golang.org/x/crypto v0.53.0 @@ -104,6 +104,7 @@ require ( github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f // indirect github.com/onsi/ginkgo/v2 v2.22.1 // indirect github.com/onsi/gomega v1.36.2 // indirect + github.com/pierrec/lz4/v4 v4.1.27 // indirect github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.10 // indirect github.com/smartcontractkit/chainlink-protos/cre/go v0.0.0-20260505131349-78e491b80735 // indirect github.com/smartcontractkit/chainlink-protos/linking-service/go v0.0.0-20251002192024-d2ad9222409b // indirect @@ -129,7 +130,7 @@ require ( require ( dario.cat/mergo v1.0.2 // indirect - filippo.io/edwards25519 v1.1.1 // indirect + filippo.io/edwards25519 v1.2.0 // indirect github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c // indirect github.com/BurntSushi/toml v1.6.0 // indirect github.com/DataDog/zstd v1.5.6 // indirect @@ -282,7 +283,6 @@ require ( github.com/shirou/gopsutil v3.21.11+incompatible // indirect github.com/shirou/gopsutil/v4 v4.26.5 // indirect github.com/shopspring/decimal v1.4.0 // indirect - github.com/sigurn/crc16 v0.0.0-20211026045750-20ab5afb07e3 // indirect github.com/sirupsen/logrus v1.9.4 // indirect github.com/smartcontractkit/chainlink-sui v0.0.0-20260630144638-b69f16bdddd8 github.com/smartcontractkit/grpc-proxy v0.0.0-20240830132753-a7e17fec5ab7 // indirect @@ -332,7 +332,7 @@ require ( go.opentelemetry.io/proto/otlp v1.10.0 // indirect go.uber.org/multierr v1.11.0 // indirect go.uber.org/ratelimit v0.3.1 // indirect - golang.org/x/net v0.55.0 // indirect + golang.org/x/net v0.56.0 // indirect golang.org/x/sync v0.21.0 // indirect golang.org/x/sys v0.46.0 // indirect golang.org/x/term v0.44.0 // indirect diff --git a/go.sum b/go.sum index 166d39fe4..417877fbb 100644 --- a/go.sum +++ b/go.sum @@ -4,8 +4,8 @@ cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCB dario.cat/mergo v1.0.2 h1:85+piFYR1tMbRrLcDwR18y4UKJ3aH1Tbzi24VRW1TK8= dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA= filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4= -filippo.io/edwards25519 v1.1.1 h1:YpjwWWlNmGIDyXOn8zLzqiD+9TyIlPhGFG96P39uBpw= -filippo.io/edwards25519 v1.1.1/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4= +filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo= +filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc= github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6 h1:He8afgbRMd7mFxO99hRNu+6tazq8nFF9lIwo9JFroBk= github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6/go.mod h1:8o94RPi1/7XTJvwPpRSzSUedZrtlirdB3r9Z20bi2f8= github.com/AlekSi/pointer v1.1.0 h1:SSDMPcXD9jSl8FPy9cRzoRaMJtm9g9ggGTxecRUbQoI= @@ -593,8 +593,8 @@ github.com/pelletier/go-toml/v2 v2.4.3 h1:GTRvJQutkOSftxIFD5xw9aepkYNuPWmVJpffdD github.com/pelletier/go-toml/v2 v2.4.3/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY= github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7 h1:oYW+YCJ1pachXTQmzR3rNLYGGz4g/UgFcjb28p/viDM= github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0= -github.com/pierrec/lz4/v4 v4.1.22 h1:cKFw6uJDK+/gfw5BcDL0JL5aBsAFdsIT18eRtLj7VIU= -github.com/pierrec/lz4/v4 v4.1.22/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= +github.com/pierrec/lz4/v4 v4.1.27 h1:+PhzhWDrjRj89TH2sw43nE3+4+W8lSxIuQadEHZyjUk= +github.com/pierrec/lz4/v4 v4.1.27/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4= github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4= github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8= github.com/pion/dtls/v2 v2.2.7/go.mod h1:8WiMkebSHFD0T+dIU+UeBaoV7kDhOW5oDCzZ7WZ/F9s= @@ -663,8 +663,6 @@ github.com/shirou/gopsutil/v4 v4.26.5/go.mod h1:LZ6ewCSkBqUpvSOf+LsTGnRinC6iaNUN github.com/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o= github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k= github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME= -github.com/sigurn/crc16 v0.0.0-20211026045750-20ab5afb07e3 h1:aQKxg3+2p+IFXXg97McgDGT5zcMrQoi0EICZs8Pgchs= -github.com/sigurn/crc16 v0.0.0-20211026045750-20ab5afb07e3/go.mod h1:9/etS5gpQq9BJsJMWg1wpLbfuSnkm8dPF6FdW2JXVhA= github.com/sirupsen/logrus v1.9.4 h1:TsZE7l11zFCLZnZ+teH4Umoq5BhEIfIzfRDZ1Uzql2w= github.com/sirupsen/logrus v1.9.4/go.mod h1:ftWc9WdOfJ0a92nsE2jF5u5ZwH8Bv2zdeOC42RjbV2g= github.com/smartcontractkit/ccip-owner-contracts v0.1.0 h1:GiBDtlx7539o7AKlDV+9LsA7vTMPv+0n7ClhSFnZFAk= @@ -804,8 +802,8 @@ github.com/xdrpp/goxdr v0.1.1 h1:E1B2c6E8eYhOVyd7yEpOyopzTPirUeF6mVOfXfGyJyc= github.com/xdrpp/goxdr v0.1.1/go.mod h1:dXo1scL/l6s7iME1gxHWo2XCppbHEKZS7m/KyYWkNzA= github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 h1:gEOO8jv9F4OT7lGCjxCBTO/36wtF6j2nSip77qHd4x4= github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM= -github.com/xssnick/tonutils-go v1.14.1 h1:zV/iVYl/h3hArS+tPsd9XrSFfGert3r21caMltPSeHg= -github.com/xssnick/tonutils-go v1.14.1/go.mod h1:68xwWjpoGGqiTbLJ0gT63sKu1Z1moCnDLLzA+DKanIg= +github.com/xssnick/tonutils-go v1.18.0 h1:VDH614303RfPQxO4e/GcfrtWbL3WanpHIfxlWVd0Ea0= +github.com/xssnick/tonutils-go v1.18.0/go.mod h1:4z7dSfiufWiE2SnzgM0IYzlwpJ5UlHyPH45HP0QZNzQ= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= @@ -942,8 +940,8 @@ golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI= golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY= -golang.org/x/net v0.55.0 h1:bcvxaJn3e1U6InsFWt1JUq1aSjnRxLzT2rtD2KfkDF8= -golang.org/x/net v0.55.0/go.mod h1:L5U2KuzuOe1lY7Z+aWVIKK6qEeJXnXV9yzGA+WCHJww= +golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o= +golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= From f77695d463f6283acd457f94ff228e5804b1e198 Mon Sep 17 00:00:00 2001 From: Gustavo Gama Date: Fri, 17 Jul 2026 16:33:12 -0300 Subject: [PATCH 2/2] update chain/ton/mocks/api_client_wrapped.go --- chain/ton/mocks/api_client_wrapped.go | 1657 +++++++++++++++++++++---- 1 file changed, 1407 insertions(+), 250 deletions(-) diff --git a/chain/ton/mocks/api_client_wrapped.go b/chain/ton/mocks/api_client_wrapped.go index d160a9309..1bc54fc3e 100644 --- a/chain/ton/mocks/api_client_wrapped.go +++ b/chain/ton/mocks/api_client_wrapped.go @@ -30,8 +30,6 @@ func NewMockAPIClientWrapped(t interface { return mock } -var _ ton.APIClientWrapped = (*MockAPIClientWrapped)(nil) - // MockAPIClientWrapped is an autogenerated mock type for the APIClientWrapped type type MockAPIClientWrapped struct { mock.Mock @@ -126,7 +124,7 @@ type MockAPIClientWrapped_CurrentMasterchainInfo_Call struct { // CurrentMasterchainInfo is a helper method to define mock.On call // - ctx context.Context -func (_e *MockAPIClientWrapped_Expecter) CurrentMasterchainInfo(ctx interface{}) *MockAPIClientWrapped_CurrentMasterchainInfo_Call { +func (_e *MockAPIClientWrapped_Expecter) CurrentMasterchainInfo(ctx any) *MockAPIClientWrapped_CurrentMasterchainInfo_Call { return &MockAPIClientWrapped_CurrentMasterchainInfo_Call{Call: _e.mock.On("CurrentMasterchainInfo", ctx)} } @@ -143,8 +141,8 @@ func (_c *MockAPIClientWrapped_CurrentMasterchainInfo_Call) Run(run func(ctx con return _c } -func (_c *MockAPIClientWrapped_CurrentMasterchainInfo_Call) Return(v *ton.BlockIDExt, err error) *MockAPIClientWrapped_CurrentMasterchainInfo_Call { - _c.Call.Return(v, err) +func (_c *MockAPIClientWrapped_CurrentMasterchainInfo_Call) Return(blockIDExt *ton.BlockIDExt, err error) *MockAPIClientWrapped_CurrentMasterchainInfo_Call { + _c.Call.Return(blockIDExt, err) return _c } @@ -197,9 +195,9 @@ type MockAPIClientWrapped_FindLastTransactionByInMsgHash_Call struct { // - addr *address.Address // - msgHash []byte // - maxTxNumToScan ...int -func (_e *MockAPIClientWrapped_Expecter) FindLastTransactionByInMsgHash(ctx interface{}, addr interface{}, msgHash interface{}, maxTxNumToScan ...interface{}) *MockAPIClientWrapped_FindLastTransactionByInMsgHash_Call { +func (_e *MockAPIClientWrapped_Expecter) FindLastTransactionByInMsgHash(ctx any, addr any, msgHash any, maxTxNumToScan ...any) *MockAPIClientWrapped_FindLastTransactionByInMsgHash_Call { return &MockAPIClientWrapped_FindLastTransactionByInMsgHash_Call{Call: _e.mock.On("FindLastTransactionByInMsgHash", - append([]interface{}{ctx, addr, msgHash}, maxTxNumToScan...)...)} + append([]any{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 { @@ -242,6 +240,86 @@ func (_c *MockAPIClientWrapped_FindLastTransactionByInMsgHash_Call) RunAndReturn return _c } +// FindLastTransactionByInMsgHashAfterTime provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) FindLastTransactionByInMsgHashAfterTime(ctx context.Context, addr *address.Address, msgHash []byte, after time.Time) (*tlb.Transaction, error) { + ret := _mock.Called(ctx, addr, msgHash, after) + + if len(ret) == 0 { + panic("no return value specified for FindLastTransactionByInMsgHashAfterTime") + } + + var r0 *tlb.Transaction + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *address.Address, []byte, time.Time) (*tlb.Transaction, error)); ok { + return returnFunc(ctx, addr, msgHash, after) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *address.Address, []byte, time.Time) *tlb.Transaction); ok { + r0 = returnFunc(ctx, addr, msgHash, after) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*tlb.Transaction) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *address.Address, []byte, time.Time) error); ok { + r1 = returnFunc(ctx, addr, msgHash, after) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_FindLastTransactionByInMsgHashAfterTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindLastTransactionByInMsgHashAfterTime' +type MockAPIClientWrapped_FindLastTransactionByInMsgHashAfterTime_Call struct { + *mock.Call +} + +// FindLastTransactionByInMsgHashAfterTime is a helper method to define mock.On call +// - ctx context.Context +// - addr *address.Address +// - msgHash []byte +// - after time.Time +func (_e *MockAPIClientWrapped_Expecter) FindLastTransactionByInMsgHashAfterTime(ctx any, addr any, msgHash any, after any) *MockAPIClientWrapped_FindLastTransactionByInMsgHashAfterTime_Call { + return &MockAPIClientWrapped_FindLastTransactionByInMsgHashAfterTime_Call{Call: _e.mock.On("FindLastTransactionByInMsgHashAfterTime", ctx, addr, msgHash, after)} +} + +func (_c *MockAPIClientWrapped_FindLastTransactionByInMsgHashAfterTime_Call) Run(run func(ctx context.Context, addr *address.Address, msgHash []byte, after time.Time)) *MockAPIClientWrapped_FindLastTransactionByInMsgHashAfterTime_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 time.Time + if args[3] != nil { + arg3 = args[3].(time.Time) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_FindLastTransactionByInMsgHashAfterTime_Call) Return(transaction *tlb.Transaction, err error) *MockAPIClientWrapped_FindLastTransactionByInMsgHashAfterTime_Call { + _c.Call.Return(transaction, err) + return _c +} + +func (_c *MockAPIClientWrapped_FindLastTransactionByInMsgHashAfterTime_Call) RunAndReturn(run func(ctx context.Context, addr *address.Address, msgHash []byte, after time.Time) (*tlb.Transaction, error)) *MockAPIClientWrapped_FindLastTransactionByInMsgHashAfterTime_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 @@ -286,9 +364,9 @@ type MockAPIClientWrapped_FindLastTransactionByOutMsgHash_Call struct { // - addr *address.Address // - msgHash []byte // - maxTxNumToScan ...int -func (_e *MockAPIClientWrapped_Expecter) FindLastTransactionByOutMsgHash(ctx interface{}, addr interface{}, msgHash interface{}, maxTxNumToScan ...interface{}) *MockAPIClientWrapped_FindLastTransactionByOutMsgHash_Call { +func (_e *MockAPIClientWrapped_Expecter) FindLastTransactionByOutMsgHash(ctx any, addr any, msgHash any, maxTxNumToScan ...any) *MockAPIClientWrapped_FindLastTransactionByOutMsgHash_Call { return &MockAPIClientWrapped_FindLastTransactionByOutMsgHash_Call{Call: _e.mock.On("FindLastTransactionByOutMsgHash", - append([]interface{}{ctx, addr, msgHash}, maxTxNumToScan...)...)} + append([]any{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 { @@ -331,6 +409,86 @@ func (_c *MockAPIClientWrapped_FindLastTransactionByOutMsgHash_Call) RunAndRetur return _c } +// FindLastTransactionByOutMsgHashAfterTime provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) FindLastTransactionByOutMsgHashAfterTime(ctx context.Context, addr *address.Address, msgHash []byte, after time.Time) (*tlb.Transaction, error) { + ret := _mock.Called(ctx, addr, msgHash, after) + + if len(ret) == 0 { + panic("no return value specified for FindLastTransactionByOutMsgHashAfterTime") + } + + var r0 *tlb.Transaction + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *address.Address, []byte, time.Time) (*tlb.Transaction, error)); ok { + return returnFunc(ctx, addr, msgHash, after) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *address.Address, []byte, time.Time) *tlb.Transaction); ok { + r0 = returnFunc(ctx, addr, msgHash, after) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*tlb.Transaction) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *address.Address, []byte, time.Time) error); ok { + r1 = returnFunc(ctx, addr, msgHash, after) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_FindLastTransactionByOutMsgHashAfterTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindLastTransactionByOutMsgHashAfterTime' +type MockAPIClientWrapped_FindLastTransactionByOutMsgHashAfterTime_Call struct { + *mock.Call +} + +// FindLastTransactionByOutMsgHashAfterTime is a helper method to define mock.On call +// - ctx context.Context +// - addr *address.Address +// - msgHash []byte +// - after time.Time +func (_e *MockAPIClientWrapped_Expecter) FindLastTransactionByOutMsgHashAfterTime(ctx any, addr any, msgHash any, after any) *MockAPIClientWrapped_FindLastTransactionByOutMsgHashAfterTime_Call { + return &MockAPIClientWrapped_FindLastTransactionByOutMsgHashAfterTime_Call{Call: _e.mock.On("FindLastTransactionByOutMsgHashAfterTime", ctx, addr, msgHash, after)} +} + +func (_c *MockAPIClientWrapped_FindLastTransactionByOutMsgHashAfterTime_Call) Run(run func(ctx context.Context, addr *address.Address, msgHash []byte, after time.Time)) *MockAPIClientWrapped_FindLastTransactionByOutMsgHashAfterTime_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 time.Time + if args[3] != nil { + arg3 = args[3].(time.Time) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_FindLastTransactionByOutMsgHashAfterTime_Call) Return(transaction *tlb.Transaction, err error) *MockAPIClientWrapped_FindLastTransactionByOutMsgHashAfterTime_Call { + _c.Call.Return(transaction, err) + return _c +} + +func (_c *MockAPIClientWrapped_FindLastTransactionByOutMsgHashAfterTime_Call) RunAndReturn(run func(ctx context.Context, addr *address.Address, msgHash []byte, after time.Time) (*tlb.Transaction, error)) *MockAPIClientWrapped_FindLastTransactionByOutMsgHashAfterTime_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) @@ -368,7 +526,7 @@ type MockAPIClientWrapped_GetAccount_Call struct { // - ctx context.Context // - block *ton.BlockIDExt // - addr *address.Address -func (_e *MockAPIClientWrapped_Expecter) GetAccount(ctx interface{}, block interface{}, addr interface{}) *MockAPIClientWrapped_GetAccount_Call { +func (_e *MockAPIClientWrapped_Expecter) GetAccount(ctx any, block any, addr any) *MockAPIClientWrapped_GetAccount_Call { return &MockAPIClientWrapped_GetAccount_Call{Call: _e.mock.On("GetAccount", ctx, block, addr)} } @@ -405,189 +563,171 @@ func (_c *MockAPIClientWrapped_GetAccount_Call) RunAndReturn(run func(ctx contex 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) +// GetAllNonfinalPendingShardBlocks provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetAllNonfinalPendingShardBlocks(ctx context.Context) (*ton.NonfinalPendingShardBlocks, error) { + ret := _mock.Called(ctx) if len(ret) == 0 { - panic("no return value specified for GetBlockData") + panic("no return value specified for GetAllNonfinalPendingShardBlocks") } - var r0 *tlb.Block + var r0 *ton.NonfinalPendingShardBlocks 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.NonfinalPendingShardBlocks, error)); ok { + return returnFunc(ctx) } - if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt) *tlb.Block); ok { - r0 = returnFunc(ctx, block) + if returnFunc, ok := ret.Get(0).(func(context.Context) *ton.NonfinalPendingShardBlocks); ok { + r0 = returnFunc(ctx) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*tlb.Block) + r0 = ret.Get(0).(*ton.NonfinalPendingShardBlocks) } } - if returnFunc, ok := ret.Get(1).(func(context.Context, *ton.BlockIDExt) error); ok { - r1 = returnFunc(ctx, block) + if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = returnFunc(ctx) } 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 { +// MockAPIClientWrapped_GetAllNonfinalPendingShardBlocks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllNonfinalPendingShardBlocks' +type MockAPIClientWrapped_GetAllNonfinalPendingShardBlocks_Call struct { *mock.Call } -// GetBlockData is a helper method to define mock.On call +// GetAllNonfinalPendingShardBlocks 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 (_e *MockAPIClientWrapped_Expecter) GetAllNonfinalPendingShardBlocks(ctx any) *MockAPIClientWrapped_GetAllNonfinalPendingShardBlocks_Call { + return &MockAPIClientWrapped_GetAllNonfinalPendingShardBlocks_Call{Call: _e.mock.On("GetAllNonfinalPendingShardBlocks", ctx)} } -func (_c *MockAPIClientWrapped_GetBlockData_Call) Run(run func(ctx context.Context, block *ton.BlockIDExt)) *MockAPIClientWrapped_GetBlockData_Call { +func (_c *MockAPIClientWrapped_GetAllNonfinalPendingShardBlocks_Call) Run(run func(ctx context.Context)) *MockAPIClientWrapped_GetAllNonfinalPendingShardBlocks_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) +func (_c *MockAPIClientWrapped_GetAllNonfinalPendingShardBlocks_Call) Return(nonfinalPendingShardBlocks *ton.NonfinalPendingShardBlocks, err error) *MockAPIClientWrapped_GetAllNonfinalPendingShardBlocks_Call { + _c.Call.Return(nonfinalPendingShardBlocks, err) return _c } -func (_c *MockAPIClientWrapped_GetBlockData_Call) RunAndReturn(run func(ctx context.Context, block *ton.BlockIDExt) (*tlb.Block, error)) *MockAPIClientWrapped_GetBlockData_Call { +func (_c *MockAPIClientWrapped_GetAllNonfinalPendingShardBlocks_Call) RunAndReturn(run func(ctx context.Context) (*ton.NonfinalPendingShardBlocks, error)) *MockAPIClientWrapped_GetAllNonfinalPendingShardBlocks_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) +// GetAllNonfinalValidatorGroups provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetAllNonfinalValidatorGroups(ctx context.Context) (*ton.NonfinalValidatorGroups, error) { + ret := _mock.Called(ctx) if len(ret) == 0 { - panic("no return value specified for GetBlockProof") + panic("no return value specified for GetAllNonfinalValidatorGroups") } - var r0 *ton.PartialBlockProof + var r0 *ton.NonfinalValidatorGroups 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.NonfinalValidatorGroups, error)); ok { + return returnFunc(ctx) } - if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, *ton.BlockIDExt) *ton.PartialBlockProof); ok { - r0 = returnFunc(ctx, known, target) + if returnFunc, ok := ret.Get(0).(func(context.Context) *ton.NonfinalValidatorGroups); ok { + r0 = returnFunc(ctx) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*ton.PartialBlockProof) + r0 = ret.Get(0).(*ton.NonfinalValidatorGroups) } } - if returnFunc, ok := ret.Get(1).(func(context.Context, *ton.BlockIDExt, *ton.BlockIDExt) error); ok { - r1 = returnFunc(ctx, known, target) + if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = returnFunc(ctx) } 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 { +// MockAPIClientWrapped_GetAllNonfinalValidatorGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllNonfinalValidatorGroups' +type MockAPIClientWrapped_GetAllNonfinalValidatorGroups_Call struct { *mock.Call } -// GetBlockProof is a helper method to define mock.On call +// GetAllNonfinalValidatorGroups 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 (_e *MockAPIClientWrapped_Expecter) GetAllNonfinalValidatorGroups(ctx any) *MockAPIClientWrapped_GetAllNonfinalValidatorGroups_Call { + return &MockAPIClientWrapped_GetAllNonfinalValidatorGroups_Call{Call: _e.mock.On("GetAllNonfinalValidatorGroups", ctx)} } -func (_c *MockAPIClientWrapped_GetBlockProof_Call) Run(run func(ctx context.Context, known *ton.BlockIDExt, target *ton.BlockIDExt)) *MockAPIClientWrapped_GetBlockProof_Call { +func (_c *MockAPIClientWrapped_GetAllNonfinalValidatorGroups_Call) Run(run func(ctx context.Context)) *MockAPIClientWrapped_GetAllNonfinalValidatorGroups_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) +func (_c *MockAPIClientWrapped_GetAllNonfinalValidatorGroups_Call) Return(nonfinalValidatorGroups *ton.NonfinalValidatorGroups, err error) *MockAPIClientWrapped_GetAllNonfinalValidatorGroups_Call { + _c.Call.Return(nonfinalValidatorGroups, 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 { +func (_c *MockAPIClientWrapped_GetAllNonfinalValidatorGroups_Call) RunAndReturn(run func(ctx context.Context) (*ton.NonfinalValidatorGroups, error)) *MockAPIClientWrapped_GetAllNonfinalValidatorGroups_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) +// 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 GetBlockShardsInfo") + panic("no return value specified for GetBlockData") } - var r0 []*ton.BlockIDExt + var r0 *tlb.Block 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) (*tlb.Block, error)); ok { + return returnFunc(ctx, block) } - if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt) []*ton.BlockIDExt); ok { - r0 = returnFunc(ctx, master) + 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).([]*ton.BlockIDExt) + r0 = ret.Get(0).(*tlb.Block) } } if returnFunc, ok := ret.Get(1).(func(context.Context, *ton.BlockIDExt) error); ok { - r1 = returnFunc(ctx, master) + r1 = returnFunc(ctx, block) } 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 { +// 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 } -// GetBlockShardsInfo is a helper method to define mock.On call +// GetBlockData 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)} +// - block *ton.BlockIDExt +func (_e *MockAPIClientWrapped_Expecter) GetBlockData(ctx any, block any) *MockAPIClientWrapped_GetBlockData_Call { + return &MockAPIClientWrapped_GetBlockData_Call{Call: _e.mock.On("GetBlockData", ctx, block)} } -func (_c *MockAPIClientWrapped_GetBlockShardsInfo_Call) Run(run func(ctx context.Context, master *ton.BlockIDExt)) *MockAPIClientWrapped_GetBlockShardsInfo_Call { +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 { @@ -605,72 +745,672 @@ func (_c *MockAPIClientWrapped_GetBlockShardsInfo_Call) Run(run func(ctx context return _c } -func (_c *MockAPIClientWrapped_GetBlockShardsInfo_Call) Return(vs []*ton.BlockIDExt, err error) *MockAPIClientWrapped_GetBlockShardsInfo_Call { - _c.Call.Return(vs, err) +func (_c *MockAPIClientWrapped_GetBlockData_Call) Return(block1 *tlb.Block, err error) *MockAPIClientWrapped_GetBlockData_Call { + _c.Call.Return(block1, err) return _c } -func (_c *MockAPIClientWrapped_GetBlockShardsInfo_Call) RunAndReturn(run func(ctx context.Context, master *ton.BlockIDExt) ([]*ton.BlockIDExt, error)) *MockAPIClientWrapped_GetBlockShardsInfo_Call { +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 } -// 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 +// GetBlockDataAsCell provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetBlockDataAsCell(ctx context.Context, block *ton.BlockIDExt) (*cell.Cell, error) { + ret := _mock.Called(ctx, block) if len(ret) == 0 { - panic("no return value specified for GetBlockTransactionsV2") + panic("no return value specified for GetBlockDataAsCell") } - 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...) + var r0 *cell.Cell + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt) (*cell.Cell, error)); ok { + return returnFunc(ctx, block) } - if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, uint32, ...*ton.TransactionID3) []ton.TransactionShortInfo); ok { - r0 = returnFunc(ctx, block, count, after...) + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt) *cell.Cell); ok { + r0 = returnFunc(ctx, block) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).([]ton.TransactionShortInfo) + r0 = ret.Get(0).(*cell.Cell) } } - if returnFunc, ok := ret.Get(1).(func(context.Context, *ton.BlockIDExt, uint32, ...*ton.TransactionID3) bool); ok { - r1 = returnFunc(ctx, block, count, after...) + if returnFunc, ok := ret.Get(1).(func(context.Context, *ton.BlockIDExt) error); ok { + r1 = returnFunc(ctx, block) } else { - r1 = ret.Get(1).(bool) + r1 = ret.Error(1) } - if returnFunc, ok := ret.Get(2).(func(context.Context, *ton.BlockIDExt, uint32, ...*ton.TransactionID3) error); ok { - r2 = returnFunc(ctx, block, count, after...) + return r0, r1 +} + +// MockAPIClientWrapped_GetBlockDataAsCell_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlockDataAsCell' +type MockAPIClientWrapped_GetBlockDataAsCell_Call struct { + *mock.Call +} + +// GetBlockDataAsCell is a helper method to define mock.On call +// - ctx context.Context +// - block *ton.BlockIDExt +func (_e *MockAPIClientWrapped_Expecter) GetBlockDataAsCell(ctx any, block any) *MockAPIClientWrapped_GetBlockDataAsCell_Call { + return &MockAPIClientWrapped_GetBlockDataAsCell_Call{Call: _e.mock.On("GetBlockDataAsCell", ctx, block)} +} + +func (_c *MockAPIClientWrapped_GetBlockDataAsCell_Call) Run(run func(ctx context.Context, block *ton.BlockIDExt)) *MockAPIClientWrapped_GetBlockDataAsCell_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_GetBlockDataAsCell_Call) Return(cell1 *cell.Cell, err error) *MockAPIClientWrapped_GetBlockDataAsCell_Call { + _c.Call.Return(cell1, err) + return _c +} + +func (_c *MockAPIClientWrapped_GetBlockDataAsCell_Call) RunAndReturn(run func(ctx context.Context, block *ton.BlockIDExt) (*cell.Cell, error)) *MockAPIClientWrapped_GetBlockDataAsCell_Call { + _c.Call.Return(run) + return _c +} + +// GetBlockHeader provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetBlockHeader(ctx context.Context, block *ton.BlockIDExt) (*tlb.BlockHeader, error) { + ret := _mock.Called(ctx, block) + + if len(ret) == 0 { + panic("no return value specified for GetBlockHeader") + } + + var r0 *tlb.BlockHeader + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt) (*tlb.BlockHeader, error)); ok { + return returnFunc(ctx, block) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt) *tlb.BlockHeader); ok { + r0 = returnFunc(ctx, block) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*tlb.BlockHeader) + } + } + 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_GetBlockHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlockHeader' +type MockAPIClientWrapped_GetBlockHeader_Call struct { + *mock.Call +} + +// GetBlockHeader is a helper method to define mock.On call +// - ctx context.Context +// - block *ton.BlockIDExt +func (_e *MockAPIClientWrapped_Expecter) GetBlockHeader(ctx any, block any) *MockAPIClientWrapped_GetBlockHeader_Call { + return &MockAPIClientWrapped_GetBlockHeader_Call{Call: _e.mock.On("GetBlockHeader", ctx, block)} +} + +func (_c *MockAPIClientWrapped_GetBlockHeader_Call) Run(run func(ctx context.Context, block *ton.BlockIDExt)) *MockAPIClientWrapped_GetBlockHeader_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_GetBlockHeader_Call) Return(blockHeader *tlb.BlockHeader, err error) *MockAPIClientWrapped_GetBlockHeader_Call { + _c.Call.Return(blockHeader, err) + return _c +} + +func (_c *MockAPIClientWrapped_GetBlockHeader_Call) RunAndReturn(run func(ctx context.Context, block *ton.BlockIDExt) (*tlb.BlockHeader, error)) *MockAPIClientWrapped_GetBlockHeader_Call { + _c.Call.Return(run) + return _c +} + +// GetBlockOutMsgQueueSize provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetBlockOutMsgQueueSize(ctx context.Context, block *ton.BlockIDExt) (*ton.BlockOutMsgQueueSize, error) { + ret := _mock.Called(ctx, block) + + if len(ret) == 0 { + panic("no return value specified for GetBlockOutMsgQueueSize") + } + + var r0 *ton.BlockOutMsgQueueSize + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt) (*ton.BlockOutMsgQueueSize, error)); ok { + return returnFunc(ctx, block) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt) *ton.BlockOutMsgQueueSize); ok { + r0 = returnFunc(ctx, block) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ton.BlockOutMsgQueueSize) + } + } + 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_GetBlockOutMsgQueueSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlockOutMsgQueueSize' +type MockAPIClientWrapped_GetBlockOutMsgQueueSize_Call struct { + *mock.Call +} + +// GetBlockOutMsgQueueSize is a helper method to define mock.On call +// - ctx context.Context +// - block *ton.BlockIDExt +func (_e *MockAPIClientWrapped_Expecter) GetBlockOutMsgQueueSize(ctx any, block any) *MockAPIClientWrapped_GetBlockOutMsgQueueSize_Call { + return &MockAPIClientWrapped_GetBlockOutMsgQueueSize_Call{Call: _e.mock.On("GetBlockOutMsgQueueSize", ctx, block)} +} + +func (_c *MockAPIClientWrapped_GetBlockOutMsgQueueSize_Call) Run(run func(ctx context.Context, block *ton.BlockIDExt)) *MockAPIClientWrapped_GetBlockOutMsgQueueSize_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_GetBlockOutMsgQueueSize_Call) Return(blockOutMsgQueueSize *ton.BlockOutMsgQueueSize, err error) *MockAPIClientWrapped_GetBlockOutMsgQueueSize_Call { + _c.Call.Return(blockOutMsgQueueSize, err) + return _c +} + +func (_c *MockAPIClientWrapped_GetBlockOutMsgQueueSize_Call) RunAndReturn(run func(ctx context.Context, block *ton.BlockIDExt) (*ton.BlockOutMsgQueueSize, error)) *MockAPIClientWrapped_GetBlockOutMsgQueueSize_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 any, known any, target any) *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 any, master any) *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(blockIDExts []*ton.BlockIDExt, err error) *MockAPIClientWrapped_GetBlockShardsInfo_Call { + _c.Call.Return(blockIDExts, 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 any, block any, count any, after ...any) *MockAPIClientWrapped_GetBlockTransactionsV2_Call { + return &MockAPIClientWrapped_GetBlockTransactionsV2_Call{Call: _e.mock.On("GetBlockTransactionsV2", + append([]any{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) (*tlb.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 *tlb.BlockchainConfig + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, ...int32) (*tlb.BlockchainConfig, error)); ok { + return returnFunc(ctx, block, onlyParams...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, ...int32) *tlb.BlockchainConfig); ok { + r0 = returnFunc(ctx, block, onlyParams...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*tlb.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 any, block any, onlyParams ...any) *MockAPIClientWrapped_GetBlockchainConfig_Call { + return &MockAPIClientWrapped_GetBlockchainConfig_Call{Call: _e.mock.On("GetBlockchainConfig", + append([]any{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 *tlb.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) (*tlb.BlockchainConfig, error)) *MockAPIClientWrapped_GetBlockchainConfig_Call { + _c.Call.Return(run) + return _c +} + +// GetDispatchQueueInfo provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetDispatchQueueInfo(ctx context.Context, block *ton.BlockIDExt, afterAddr *address.Address, maxAccounts int) (*ton.DispatchQueueInfo, error) { + ret := _mock.Called(ctx, block, afterAddr, maxAccounts) + + if len(ret) == 0 { + panic("no return value specified for GetDispatchQueueInfo") + } + + var r0 *ton.DispatchQueueInfo + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, *address.Address, int) (*ton.DispatchQueueInfo, error)); ok { + return returnFunc(ctx, block, afterAddr, maxAccounts) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, *address.Address, int) *ton.DispatchQueueInfo); ok { + r0 = returnFunc(ctx, block, afterAddr, maxAccounts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ton.DispatchQueueInfo) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *ton.BlockIDExt, *address.Address, int) error); ok { + r1 = returnFunc(ctx, block, afterAddr, maxAccounts) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_GetDispatchQueueInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDispatchQueueInfo' +type MockAPIClientWrapped_GetDispatchQueueInfo_Call struct { + *mock.Call +} + +// GetDispatchQueueInfo is a helper method to define mock.On call +// - ctx context.Context +// - block *ton.BlockIDExt +// - afterAddr *address.Address +// - maxAccounts int +func (_e *MockAPIClientWrapped_Expecter) GetDispatchQueueInfo(ctx any, block any, afterAddr any, maxAccounts any) *MockAPIClientWrapped_GetDispatchQueueInfo_Call { + return &MockAPIClientWrapped_GetDispatchQueueInfo_Call{Call: _e.mock.On("GetDispatchQueueInfo", ctx, block, afterAddr, maxAccounts)} +} + +func (_c *MockAPIClientWrapped_GetDispatchQueueInfo_Call) Run(run func(ctx context.Context, block *ton.BlockIDExt, afterAddr *address.Address, maxAccounts int)) *MockAPIClientWrapped_GetDispatchQueueInfo_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 int + if args[3] != nil { + arg3 = args[3].(int) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_GetDispatchQueueInfo_Call) Return(dispatchQueueInfo *ton.DispatchQueueInfo, err error) *MockAPIClientWrapped_GetDispatchQueueInfo_Call { + _c.Call.Return(dispatchQueueInfo, err) + return _c +} + +func (_c *MockAPIClientWrapped_GetDispatchQueueInfo_Call) RunAndReturn(run func(ctx context.Context, block *ton.BlockIDExt, afterAddr *address.Address, maxAccounts int) (*ton.DispatchQueueInfo, error)) *MockAPIClientWrapped_GetDispatchQueueInfo_Call { + _c.Call.Return(run) + return _c +} + +// GetDispatchQueueMessages provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetDispatchQueueMessages(ctx context.Context, block *ton.BlockIDExt, addr *address.Address, afterLT uint64, maxMessages int, options ...func(*ton.GetDispatchQueueMessages)) (*ton.DispatchQueueMessages, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(ctx, block, addr, afterLT, maxMessages, options) } else { - r2 = ret.Error(2) + tmpRet = _mock.Called(ctx, block, addr, afterLT, maxMessages) } - return r0, r1, r2 + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetDispatchQueueMessages") + } + + var r0 *ton.DispatchQueueMessages + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, *address.Address, uint64, int, ...func(*ton.GetDispatchQueueMessages)) (*ton.DispatchQueueMessages, error)); ok { + return returnFunc(ctx, block, addr, afterLT, maxMessages, options...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, *address.Address, uint64, int, ...func(*ton.GetDispatchQueueMessages)) *ton.DispatchQueueMessages); ok { + r0 = returnFunc(ctx, block, addr, afterLT, maxMessages, options...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ton.DispatchQueueMessages) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *ton.BlockIDExt, *address.Address, uint64, int, ...func(*ton.GetDispatchQueueMessages)) error); ok { + r1 = returnFunc(ctx, block, addr, afterLT, maxMessages, options...) + } else { + r1 = ret.Error(1) + } + return r0, r1 } -// MockAPIClientWrapped_GetBlockTransactionsV2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlockTransactionsV2' -type MockAPIClientWrapped_GetBlockTransactionsV2_Call struct { +// MockAPIClientWrapped_GetDispatchQueueMessages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDispatchQueueMessages' +type MockAPIClientWrapped_GetDispatchQueueMessages_Call struct { *mock.Call } -// GetBlockTransactionsV2 is a helper method to define mock.On call +// GetDispatchQueueMessages 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...)...)} +// - addr *address.Address +// - afterLT uint64 +// - maxMessages int +// - options ...func(*ton.GetDispatchQueueMessages) +func (_e *MockAPIClientWrapped_Expecter) GetDispatchQueueMessages(ctx any, block any, addr any, afterLT any, maxMessages any, options ...any) *MockAPIClientWrapped_GetDispatchQueueMessages_Call { + return &MockAPIClientWrapped_GetDispatchQueueMessages_Call{Call: _e.mock.On("GetDispatchQueueMessages", + append([]any{ctx, block, addr, afterLT, maxMessages}, options...)...)} } -func (_c *MockAPIClientWrapped_GetBlockTransactionsV2_Call) Run(run func(ctx context.Context, block *ton.BlockIDExt, count uint32, after ...*ton.TransactionID3)) *MockAPIClientWrapped_GetBlockTransactionsV2_Call { +func (_c *MockAPIClientWrapped_GetDispatchQueueMessages_Call) Run(run func(ctx context.Context, block *ton.BlockIDExt, addr *address.Address, afterLT uint64, maxMessages int, options ...func(*ton.GetDispatchQueueMessages))) *MockAPIClientWrapped_GetDispatchQueueMessages_Call { _c.Call.Run(func(args mock.Arguments) { var arg0 context.Context if args[0] != nil { @@ -680,254 +1420,471 @@ func (_c *MockAPIClientWrapped_GetBlockTransactionsV2_Call) Run(run func(ctx con if args[1] != nil { arg1 = args[1].(*ton.BlockIDExt) } - var arg2 uint32 + var arg2 *address.Address if args[2] != nil { - arg2 = args[2].(uint32) + arg2 = args[2].(*address.Address) } - var arg3 []*ton.TransactionID3 - var variadicArgs []*ton.TransactionID3 - if len(args) > 3 { - variadicArgs = args[3].([]*ton.TransactionID3) + var arg3 uint64 + if args[3] != nil { + arg3 = args[3].(uint64) } - arg3 = variadicArgs + var arg4 int + if args[4] != nil { + arg4 = args[4].(int) + } + var arg5 []func(*ton.GetDispatchQueueMessages) + var variadicArgs []func(*ton.GetDispatchQueueMessages) + if len(args) > 5 { + variadicArgs = args[5].([]func(*ton.GetDispatchQueueMessages)) + } + arg5 = variadicArgs run( arg0, arg1, arg2, - arg3..., + arg3, + arg4, + arg5..., + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_GetDispatchQueueMessages_Call) Return(dispatchQueueMessages *ton.DispatchQueueMessages, err error) *MockAPIClientWrapped_GetDispatchQueueMessages_Call { + _c.Call.Return(dispatchQueueMessages, err) + return _c +} + +func (_c *MockAPIClientWrapped_GetDispatchQueueMessages_Call) RunAndReturn(run func(ctx context.Context, block *ton.BlockIDExt, addr *address.Address, afterLT uint64, maxMessages int, options ...func(*ton.GetDispatchQueueMessages)) (*ton.DispatchQueueMessages, error)) *MockAPIClientWrapped_GetDispatchQueueMessages_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 any, list ...any) *MockAPIClientWrapped_GetLibraries_Call { + return &MockAPIClientWrapped_GetLibraries_Call{Call: _e.mock.On("GetLibraries", + append([]any{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 any) *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(blockIDExt *ton.BlockIDExt, err error) *MockAPIClientWrapped_GetMasterchainInfo_Call { + _c.Call.Return(blockIDExt, 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 +} + +// GetNonfinalCandidate provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetNonfinalCandidate(ctx context.Context, id *ton.NonfinalCandidateID) (*ton.NonfinalCandidate, error) { + ret := _mock.Called(ctx, id) + + if len(ret) == 0 { + panic("no return value specified for GetNonfinalCandidate") + } + + var r0 *ton.NonfinalCandidate + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.NonfinalCandidateID) (*ton.NonfinalCandidate, error)); ok { + return returnFunc(ctx, id) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.NonfinalCandidateID) *ton.NonfinalCandidate); ok { + r0 = returnFunc(ctx, id) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ton.NonfinalCandidate) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *ton.NonfinalCandidateID) error); ok { + r1 = returnFunc(ctx, id) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_GetNonfinalCandidate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNonfinalCandidate' +type MockAPIClientWrapped_GetNonfinalCandidate_Call struct { + *mock.Call +} + +// GetNonfinalCandidate is a helper method to define mock.On call +// - ctx context.Context +// - id *ton.NonfinalCandidateID +func (_e *MockAPIClientWrapped_Expecter) GetNonfinalCandidate(ctx any, id any) *MockAPIClientWrapped_GetNonfinalCandidate_Call { + return &MockAPIClientWrapped_GetNonfinalCandidate_Call{Call: _e.mock.On("GetNonfinalCandidate", ctx, id)} +} + +func (_c *MockAPIClientWrapped_GetNonfinalCandidate_Call) Run(run func(ctx context.Context, id *ton.NonfinalCandidateID)) *MockAPIClientWrapped_GetNonfinalCandidate_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *ton.NonfinalCandidateID + if args[1] != nil { + arg1 = args[1].(*ton.NonfinalCandidateID) + } + run( + arg0, + arg1, ) }) return _c } -func (_c *MockAPIClientWrapped_GetBlockTransactionsV2_Call) Return(transactionShortInfos []ton.TransactionShortInfo, b bool, err error) *MockAPIClientWrapped_GetBlockTransactionsV2_Call { - _c.Call.Return(transactionShortInfos, b, err) +func (_c *MockAPIClientWrapped_GetNonfinalCandidate_Call) Return(nonfinalCandidate *ton.NonfinalCandidate, err error) *MockAPIClientWrapped_GetNonfinalCandidate_Call { + _c.Call.Return(nonfinalCandidate, 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 { +func (_c *MockAPIClientWrapped_GetNonfinalCandidate_Call) RunAndReturn(run func(ctx context.Context, id *ton.NonfinalCandidateID) (*ton.NonfinalCandidate, error)) *MockAPIClientWrapped_GetNonfinalCandidate_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 +// GetNonfinalPendingShardBlocks provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetNonfinalPendingShardBlocks(ctx context.Context, wc int32, shard int64) (*ton.NonfinalPendingShardBlocks, error) { + ret := _mock.Called(ctx, wc, shard) if len(ret) == 0 { - panic("no return value specified for GetBlockchainConfig") + panic("no return value specified for GetNonfinalPendingShardBlocks") } - var r0 *ton.BlockchainConfig + var r0 *ton.NonfinalPendingShardBlocks 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, int32, int64) (*ton.NonfinalPendingShardBlocks, error)); ok { + return returnFunc(ctx, wc, shard) } - if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, ...int32) *ton.BlockchainConfig); ok { - r0 = returnFunc(ctx, block, onlyParams...) + if returnFunc, ok := ret.Get(0).(func(context.Context, int32, int64) *ton.NonfinalPendingShardBlocks); ok { + r0 = returnFunc(ctx, wc, shard) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*ton.BlockchainConfig) + r0 = ret.Get(0).(*ton.NonfinalPendingShardBlocks) } } - if returnFunc, ok := ret.Get(1).(func(context.Context, *ton.BlockIDExt, ...int32) error); ok { - r1 = returnFunc(ctx, block, onlyParams...) + if returnFunc, ok := ret.Get(1).(func(context.Context, int32, int64) error); ok { + r1 = returnFunc(ctx, wc, shard) } 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 { +// MockAPIClientWrapped_GetNonfinalPendingShardBlocks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNonfinalPendingShardBlocks' +type MockAPIClientWrapped_GetNonfinalPendingShardBlocks_Call struct { *mock.Call } -// GetBlockchainConfig is a helper method to define mock.On call +// GetNonfinalPendingShardBlocks 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...)...)} +// - wc int32 +// - shard int64 +func (_e *MockAPIClientWrapped_Expecter) GetNonfinalPendingShardBlocks(ctx any, wc any, shard any) *MockAPIClientWrapped_GetNonfinalPendingShardBlocks_Call { + return &MockAPIClientWrapped_GetNonfinalPendingShardBlocks_Call{Call: _e.mock.On("GetNonfinalPendingShardBlocks", ctx, wc, shard)} } -func (_c *MockAPIClientWrapped_GetBlockchainConfig_Call) Run(run func(ctx context.Context, block *ton.BlockIDExt, onlyParams ...int32)) *MockAPIClientWrapped_GetBlockchainConfig_Call { +func (_c *MockAPIClientWrapped_GetNonfinalPendingShardBlocks_Call) Run(run func(ctx context.Context, wc int32, shard int64)) *MockAPIClientWrapped_GetNonfinalPendingShardBlocks_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 + var arg1 int32 if args[1] != nil { - arg1 = args[1].(*ton.BlockIDExt) + arg1 = args[1].(int32) } - var arg2 []int32 - var variadicArgs []int32 - if len(args) > 2 { - variadicArgs = args[2].([]int32) + var arg2 int64 + if args[2] != nil { + arg2 = args[2].(int64) } - arg2 = variadicArgs run( arg0, arg1, - arg2..., + arg2, ) }) return _c } -func (_c *MockAPIClientWrapped_GetBlockchainConfig_Call) Return(blockchainConfig *ton.BlockchainConfig, err error) *MockAPIClientWrapped_GetBlockchainConfig_Call { - _c.Call.Return(blockchainConfig, err) +func (_c *MockAPIClientWrapped_GetNonfinalPendingShardBlocks_Call) Return(nonfinalPendingShardBlocks *ton.NonfinalPendingShardBlocks, err error) *MockAPIClientWrapped_GetNonfinalPendingShardBlocks_Call { + _c.Call.Return(nonfinalPendingShardBlocks, 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 { +func (_c *MockAPIClientWrapped_GetNonfinalPendingShardBlocks_Call) RunAndReturn(run func(ctx context.Context, wc int32, shard int64) (*ton.NonfinalPendingShardBlocks, error)) *MockAPIClientWrapped_GetNonfinalPendingShardBlocks_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 +// GetNonfinalValidatorGroups provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetNonfinalValidatorGroups(ctx context.Context, wc int32, shard int64) (*ton.NonfinalValidatorGroups, error) { + ret := _mock.Called(ctx, wc, shard) if len(ret) == 0 { - panic("no return value specified for GetLibraries") + panic("no return value specified for GetNonfinalValidatorGroups") } - var r0 []*cell.Cell + var r0 *ton.NonfinalValidatorGroups 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, int32, int64) (*ton.NonfinalValidatorGroups, error)); ok { + return returnFunc(ctx, wc, shard) } - if returnFunc, ok := ret.Get(0).(func(context.Context, ...[]byte) []*cell.Cell); ok { - r0 = returnFunc(ctx, list...) + if returnFunc, ok := ret.Get(0).(func(context.Context, int32, int64) *ton.NonfinalValidatorGroups); ok { + r0 = returnFunc(ctx, wc, shard) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).([]*cell.Cell) + r0 = ret.Get(0).(*ton.NonfinalValidatorGroups) } } - if returnFunc, ok := ret.Get(1).(func(context.Context, ...[]byte) error); ok { - r1 = returnFunc(ctx, list...) + if returnFunc, ok := ret.Get(1).(func(context.Context, int32, int64) error); ok { + r1 = returnFunc(ctx, wc, shard) } 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 { +// MockAPIClientWrapped_GetNonfinalValidatorGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNonfinalValidatorGroups' +type MockAPIClientWrapped_GetNonfinalValidatorGroups_Call struct { *mock.Call } -// GetLibraries is a helper method to define mock.On call +// GetNonfinalValidatorGroups 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...)...)} +// - wc int32 +// - shard int64 +func (_e *MockAPIClientWrapped_Expecter) GetNonfinalValidatorGroups(ctx any, wc any, shard any) *MockAPIClientWrapped_GetNonfinalValidatorGroups_Call { + return &MockAPIClientWrapped_GetNonfinalValidatorGroups_Call{Call: _e.mock.On("GetNonfinalValidatorGroups", ctx, wc, shard)} } -func (_c *MockAPIClientWrapped_GetLibraries_Call) Run(run func(ctx context.Context, list ...[]byte)) *MockAPIClientWrapped_GetLibraries_Call { +func (_c *MockAPIClientWrapped_GetNonfinalValidatorGroups_Call) Run(run func(ctx context.Context, wc int32, shard int64)) *MockAPIClientWrapped_GetNonfinalValidatorGroups_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) + var arg1 int32 + if args[1] != nil { + arg1 = args[1].(int32) + } + var arg2 int64 + if args[2] != nil { + arg2 = args[2].(int64) } - arg1 = variadicArgs run( arg0, - arg1..., + arg1, + arg2, ) }) return _c } -func (_c *MockAPIClientWrapped_GetLibraries_Call) Return(cells []*cell.Cell, err error) *MockAPIClientWrapped_GetLibraries_Call { - _c.Call.Return(cells, err) +func (_c *MockAPIClientWrapped_GetNonfinalValidatorGroups_Call) Return(nonfinalValidatorGroups *ton.NonfinalValidatorGroups, err error) *MockAPIClientWrapped_GetNonfinalValidatorGroups_Call { + _c.Call.Return(nonfinalValidatorGroups, err) return _c } -func (_c *MockAPIClientWrapped_GetLibraries_Call) RunAndReturn(run func(ctx context.Context, list ...[]byte) ([]*cell.Cell, error)) *MockAPIClientWrapped_GetLibraries_Call { +func (_c *MockAPIClientWrapped_GetNonfinalValidatorGroups_Call) RunAndReturn(run func(ctx context.Context, wc int32, shard int64) (*ton.NonfinalValidatorGroups, error)) *MockAPIClientWrapped_GetNonfinalValidatorGroups_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) +// GetOutMsgQueueSizes provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) GetOutMsgQueueSizes(ctx context.Context, wc *int32, shard *int64) (*ton.OutMsgQueueSizes, error) { + ret := _mock.Called(ctx, wc, shard) if len(ret) == 0 { - panic("no return value specified for GetMasterchainInfo") + panic("no return value specified for GetOutMsgQueueSizes") } - var r0 *ton.BlockIDExt + var r0 *ton.OutMsgQueueSizes 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, *int32, *int64) (*ton.OutMsgQueueSizes, error)); ok { + return returnFunc(ctx, wc, shard) } - if returnFunc, ok := ret.Get(0).(func(context.Context) *ton.BlockIDExt); ok { - r0 = returnFunc(ctx) + if returnFunc, ok := ret.Get(0).(func(context.Context, *int32, *int64) *ton.OutMsgQueueSizes); ok { + r0 = returnFunc(ctx, wc, shard) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*ton.BlockIDExt) + r0 = ret.Get(0).(*ton.OutMsgQueueSizes) } } - if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok { - r1 = returnFunc(ctx) + if returnFunc, ok := ret.Get(1).(func(context.Context, *int32, *int64) error); ok { + r1 = returnFunc(ctx, wc, shard) } 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 { +// MockAPIClientWrapped_GetOutMsgQueueSizes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOutMsgQueueSizes' +type MockAPIClientWrapped_GetOutMsgQueueSizes_Call struct { *mock.Call } -// GetMasterchainInfo is a helper method to define mock.On call +// GetOutMsgQueueSizes 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)} +// - wc *int32 +// - shard *int64 +func (_e *MockAPIClientWrapped_Expecter) GetOutMsgQueueSizes(ctx any, wc any, shard any) *MockAPIClientWrapped_GetOutMsgQueueSizes_Call { + return &MockAPIClientWrapped_GetOutMsgQueueSizes_Call{Call: _e.mock.On("GetOutMsgQueueSizes", ctx, wc, shard)} } -func (_c *MockAPIClientWrapped_GetMasterchainInfo_Call) Run(run func(ctx context.Context)) *MockAPIClientWrapped_GetMasterchainInfo_Call { +func (_c *MockAPIClientWrapped_GetOutMsgQueueSizes_Call) Run(run func(ctx context.Context, wc *int32, shard *int64)) *MockAPIClientWrapped_GetOutMsgQueueSizes_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) + } run( arg0, + arg1, + arg2, ) }) return _c } -func (_c *MockAPIClientWrapped_GetMasterchainInfo_Call) Return(v *ton.BlockIDExt, err error) *MockAPIClientWrapped_GetMasterchainInfo_Call { - _c.Call.Return(v, err) +func (_c *MockAPIClientWrapped_GetOutMsgQueueSizes_Call) Return(outMsgQueueSizes *ton.OutMsgQueueSizes, err error) *MockAPIClientWrapped_GetOutMsgQueueSizes_Call { + _c.Call.Return(outMsgQueueSizes, err) return _c } -func (_c *MockAPIClientWrapped_GetMasterchainInfo_Call) RunAndReturn(run func(ctx context.Context) (*ton.BlockIDExt, error)) *MockAPIClientWrapped_GetMasterchainInfo_Call { +func (_c *MockAPIClientWrapped_GetOutMsgQueueSizes_Call) RunAndReturn(run func(ctx context.Context, wc *int32, shard *int64) (*ton.OutMsgQueueSizes, error)) *MockAPIClientWrapped_GetOutMsgQueueSizes_Call { _c.Call.Return(run) return _c } @@ -965,7 +1922,7 @@ type MockAPIClientWrapped_GetTime_Call struct { // GetTime is a helper method to define mock.On call // - ctx context.Context -func (_e *MockAPIClientWrapped_Expecter) GetTime(ctx interface{}) *MockAPIClientWrapped_GetTime_Call { +func (_e *MockAPIClientWrapped_Expecter) GetTime(ctx any) *MockAPIClientWrapped_GetTime_Call { return &MockAPIClientWrapped_GetTime_Call{Call: _e.mock.On("GetTime", ctx)} } @@ -1030,7 +1987,7 @@ type MockAPIClientWrapped_GetTransaction_Call struct { // - block *ton.BlockIDExt // - addr *address.Address // - lt uint64 -func (_e *MockAPIClientWrapped_Expecter) GetTransaction(ctx interface{}, block interface{}, addr interface{}, lt interface{}) *MockAPIClientWrapped_GetTransaction_Call { +func (_e *MockAPIClientWrapped_Expecter) GetTransaction(ctx any, block any, addr any, lt any) *MockAPIClientWrapped_GetTransaction_Call { return &MockAPIClientWrapped_GetTransaction_Call{Call: _e.mock.On("GetTransaction", ctx, block, addr, lt)} } @@ -1111,7 +2068,7 @@ type MockAPIClientWrapped_ListTransactions_Call struct { // - num uint32 // - lt uint64 // - txHash []byte -func (_e *MockAPIClientWrapped_Expecter) ListTransactions(ctx interface{}, addr interface{}, num interface{}, lt interface{}, txHash interface{}) *MockAPIClientWrapped_ListTransactions_Call { +func (_e *MockAPIClientWrapped_Expecter) ListTransactions(ctx any, addr any, num any, lt any, txHash any) *MockAPIClientWrapped_ListTransactions_Call { return &MockAPIClientWrapped_ListTransactions_Call{Call: _e.mock.On("ListTransactions", ctx, addr, num, lt, txHash)} } @@ -1196,7 +2153,7 @@ type MockAPIClientWrapped_LookupBlock_Call struct { // - workchain int32 // - shard int64 // - seqno uint32 -func (_e *MockAPIClientWrapped_Expecter) LookupBlock(ctx interface{}, workchain interface{}, shard interface{}, seqno interface{}) *MockAPIClientWrapped_LookupBlock_Call { +func (_e *MockAPIClientWrapped_Expecter) LookupBlock(ctx any, workchain any, shard any, seqno any) *MockAPIClientWrapped_LookupBlock_Call { return &MockAPIClientWrapped_LookupBlock_Call{Call: _e.mock.On("LookupBlock", ctx, workchain, shard, seqno)} } @@ -1228,8 +2185,8 @@ func (_c *MockAPIClientWrapped_LookupBlock_Call) Run(run func(ctx context.Contex return _c } -func (_c *MockAPIClientWrapped_LookupBlock_Call) Return(v *ton.BlockIDExt, err error) *MockAPIClientWrapped_LookupBlock_Call { - _c.Call.Return(v, err) +func (_c *MockAPIClientWrapped_LookupBlock_Call) Return(blockIDExt *ton.BlockIDExt, err error) *MockAPIClientWrapped_LookupBlock_Call { + _c.Call.Return(blockIDExt, err) return _c } @@ -1283,9 +2240,9 @@ type MockAPIClientWrapped_RunGetMethod_Call struct { // - 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 { +func (_e *MockAPIClientWrapped_Expecter) RunGetMethod(ctx any, blockInfo any, addr any, method any, params ...any) *MockAPIClientWrapped_RunGetMethod_Call { return &MockAPIClientWrapped_RunGetMethod_Call{Call: _e.mock.On("RunGetMethod", - append([]interface{}{ctx, blockInfo, addr, method}, params...)...)} + append([]any{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 { @@ -1333,6 +2290,101 @@ func (_c *MockAPIClientWrapped_RunGetMethod_Call) RunAndReturn(run func(ctx cont return _c } +// RunGetMethodByID provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) RunGetMethodByID(ctx context.Context, blockInfo *ton.BlockIDExt, addr *address.Address, methodID uint64, params ...interface{}) (*ton.ExecutionResult, error) { + var tmpRet mock.Arguments + if len(params) > 0 { + tmpRet = _mock.Called(ctx, blockInfo, addr, methodID, params) + } else { + tmpRet = _mock.Called(ctx, blockInfo, addr, methodID) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for RunGetMethodByID") + } + + var r0 *ton.ExecutionResult + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, *address.Address, uint64, ...interface{}) (*ton.ExecutionResult, error)); ok { + return returnFunc(ctx, blockInfo, addr, methodID, params...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *ton.BlockIDExt, *address.Address, uint64, ...interface{}) *ton.ExecutionResult); ok { + r0 = returnFunc(ctx, blockInfo, addr, methodID, 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, uint64, ...interface{}) error); ok { + r1 = returnFunc(ctx, blockInfo, addr, methodID, params...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockAPIClientWrapped_RunGetMethodByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunGetMethodByID' +type MockAPIClientWrapped_RunGetMethodByID_Call struct { + *mock.Call +} + +// RunGetMethodByID is a helper method to define mock.On call +// - ctx context.Context +// - blockInfo *ton.BlockIDExt +// - addr *address.Address +// - methodID uint64 +// - params ...interface{} +func (_e *MockAPIClientWrapped_Expecter) RunGetMethodByID(ctx any, blockInfo any, addr any, methodID any, params ...any) *MockAPIClientWrapped_RunGetMethodByID_Call { + return &MockAPIClientWrapped_RunGetMethodByID_Call{Call: _e.mock.On("RunGetMethodByID", + append([]any{ctx, blockInfo, addr, methodID}, params...)...)} +} + +func (_c *MockAPIClientWrapped_RunGetMethodByID_Call) Run(run func(ctx context.Context, blockInfo *ton.BlockIDExt, addr *address.Address, methodID uint64, params ...interface{})) *MockAPIClientWrapped_RunGetMethodByID_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) + } + 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_RunGetMethodByID_Call) Return(executionResult *ton.ExecutionResult, err error) *MockAPIClientWrapped_RunGetMethodByID_Call { + _c.Call.Return(executionResult, err) + return _c +} + +func (_c *MockAPIClientWrapped_RunGetMethodByID_Call) RunAndReturn(run func(ctx context.Context, blockInfo *ton.BlockIDExt, addr *address.Address, methodID uint64, params ...interface{}) (*ton.ExecutionResult, error)) *MockAPIClientWrapped_RunGetMethodByID_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) @@ -1358,7 +2410,7 @@ type MockAPIClientWrapped_SendExternalMessage_Call struct { // 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 { +func (_e *MockAPIClientWrapped_Expecter) SendExternalMessage(ctx any, msg any) *MockAPIClientWrapped_SendExternalMessage_Call { return &MockAPIClientWrapped_SendExternalMessage_Call{Call: _e.mock.On("SendExternalMessage", ctx, msg)} } @@ -1442,7 +2494,7 @@ type MockAPIClientWrapped_SendExternalMessageWaitTransaction_Call struct { // 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 { +func (_e *MockAPIClientWrapped_Expecter) SendExternalMessageWaitTransaction(ctx any, msg any) *MockAPIClientWrapped_SendExternalMessageWaitTransaction_Call { return &MockAPIClientWrapped_SendExternalMessageWaitTransaction_Call{Call: _e.mock.On("SendExternalMessageWaitTransaction", ctx, msg)} } @@ -1464,8 +2516,8 @@ func (_c *MockAPIClientWrapped_SendExternalMessageWaitTransaction_Call) Run(run 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) +func (_c *MockAPIClientWrapped_SendExternalMessageWaitTransaction_Call) Return(transaction *tlb.Transaction, blockIDExt *ton.BlockIDExt, bytes []byte, err error) *MockAPIClientWrapped_SendExternalMessageWaitTransaction_Call { + _c.Call.Return(transaction, blockIDExt, bytes, err) return _c } @@ -1487,7 +2539,7 @@ type MockAPIClientWrapped_SetTrustedBlock_Call struct { // SetTrustedBlock is a helper method to define mock.On call // - block *ton.BlockIDExt -func (_e *MockAPIClientWrapped_Expecter) SetTrustedBlock(block interface{}) *MockAPIClientWrapped_SetTrustedBlock_Call { +func (_e *MockAPIClientWrapped_Expecter) SetTrustedBlock(block any) *MockAPIClientWrapped_SetTrustedBlock_Call { return &MockAPIClientWrapped_SetTrustedBlock_Call{Call: _e.mock.On("SetTrustedBlock", block)} } @@ -1527,7 +2579,7 @@ type MockAPIClientWrapped_SetTrustedBlockFromConfig_Call struct { // SetTrustedBlockFromConfig is a helper method to define mock.On call // - cfg *liteclient.GlobalConfig -func (_e *MockAPIClientWrapped_Expecter) SetTrustedBlockFromConfig(cfg interface{}) *MockAPIClientWrapped_SetTrustedBlockFromConfig_Call { +func (_e *MockAPIClientWrapped_Expecter) SetTrustedBlockFromConfig(cfg any) *MockAPIClientWrapped_SetTrustedBlockFromConfig_Call { return &MockAPIClientWrapped_SetTrustedBlockFromConfig_Call{Call: _e.mock.On("SetTrustedBlockFromConfig", cfg)} } @@ -1570,7 +2622,7 @@ type MockAPIClientWrapped_SubscribeOnTransactions_Call struct { // - 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 { +func (_e *MockAPIClientWrapped_Expecter) SubscribeOnTransactions(workerCtx any, addr any, lastProcessedLT any, channel any) *MockAPIClientWrapped_SubscribeOnTransactions_Call { return &MockAPIClientWrapped_SubscribeOnTransactions_Call{Call: _e.mock.On("SubscribeOnTransactions", workerCtx, addr, lastProcessedLT, channel)} } @@ -1638,7 +2690,7 @@ type MockAPIClientWrapped_VerifyProofChain_Call struct { // - ctx context.Context // - from *ton.BlockIDExt // - to *ton.BlockIDExt -func (_e *MockAPIClientWrapped_Expecter) VerifyProofChain(ctx interface{}, from interface{}, to interface{}) *MockAPIClientWrapped_VerifyProofChain_Call { +func (_e *MockAPIClientWrapped_Expecter) VerifyProofChain(ctx any, from any, to any) *MockAPIClientWrapped_VerifyProofChain_Call { return &MockAPIClientWrapped_VerifyProofChain_Call{Call: _e.mock.On("VerifyProofChain", ctx, from, to)} } @@ -1701,7 +2753,7 @@ type MockAPIClientWrapped_WaitForBlock_Call struct { // WaitForBlock is a helper method to define mock.On call // - seqno uint32 -func (_e *MockAPIClientWrapped_Expecter) WaitForBlock(seqno interface{}) *MockAPIClientWrapped_WaitForBlock_Call { +func (_e *MockAPIClientWrapped_Expecter) WaitForBlock(seqno any) *MockAPIClientWrapped_WaitForBlock_Call { return &MockAPIClientWrapped_WaitForBlock_Call{Call: _e.mock.On("WaitForBlock", seqno)} } @@ -1728,6 +2780,52 @@ func (_c *MockAPIClientWrapped_WaitForBlock_Call) RunAndReturn(run func(seqno ui return _c } +// WithLSInfoInErrors provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) WithLSInfoInErrors() ton.APIClientWrapped { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for WithLSInfoInErrors") + } + + var r0 ton.APIClientWrapped + if returnFunc, ok := ret.Get(0).(func() ton.APIClientWrapped); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(ton.APIClientWrapped) + } + } + return r0 +} + +// MockAPIClientWrapped_WithLSInfoInErrors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithLSInfoInErrors' +type MockAPIClientWrapped_WithLSInfoInErrors_Call struct { + *mock.Call +} + +// WithLSInfoInErrors is a helper method to define mock.On call +func (_e *MockAPIClientWrapped_Expecter) WithLSInfoInErrors() *MockAPIClientWrapped_WithLSInfoInErrors_Call { + return &MockAPIClientWrapped_WithLSInfoInErrors_Call{Call: _e.mock.On("WithLSInfoInErrors")} +} + +func (_c *MockAPIClientWrapped_WithLSInfoInErrors_Call) Run(run func()) *MockAPIClientWrapped_WithLSInfoInErrors_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAPIClientWrapped_WithLSInfoInErrors_Call) Return(aPIClientWrapped ton.APIClientWrapped) *MockAPIClientWrapped_WithLSInfoInErrors_Call { + _c.Call.Return(aPIClientWrapped) + return _c +} + +func (_c *MockAPIClientWrapped_WithLSInfoInErrors_Call) RunAndReturn(run func() ton.APIClientWrapped) *MockAPIClientWrapped_WithLSInfoInErrors_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 @@ -1760,9 +2858,9 @@ type MockAPIClientWrapped_WithRetry_Call struct { // WithRetry is a helper method to define mock.On call // - maxRetries ...int -func (_e *MockAPIClientWrapped_Expecter) WithRetry(maxRetries ...interface{}) *MockAPIClientWrapped_WithRetry_Call { +func (_e *MockAPIClientWrapped_Expecter) WithRetry(maxRetries ...any) *MockAPIClientWrapped_WithRetry_Call { return &MockAPIClientWrapped_WithRetry_Call{Call: _e.mock.On("WithRetry", - append([]interface{}{}, maxRetries...)...)} + append([]any{}, maxRetries...)...)} } func (_c *MockAPIClientWrapped_WithRetry_Call) Run(run func(maxRetries ...int)) *MockAPIClientWrapped_WithRetry_Call { @@ -1790,6 +2888,65 @@ func (_c *MockAPIClientWrapped_WithRetry_Call) RunAndReturn(run func(maxRetries return _c } +// WithRetryTimeout provides a mock function for the type MockAPIClientWrapped +func (_mock *MockAPIClientWrapped) WithRetryTimeout(maxRetries int, timeout time.Duration) ton.APIClientWrapped { + ret := _mock.Called(maxRetries, timeout) + + if len(ret) == 0 { + panic("no return value specified for WithRetryTimeout") + } + + var r0 ton.APIClientWrapped + if returnFunc, ok := ret.Get(0).(func(int, time.Duration) ton.APIClientWrapped); ok { + r0 = returnFunc(maxRetries, timeout) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(ton.APIClientWrapped) + } + } + return r0 +} + +// MockAPIClientWrapped_WithRetryTimeout_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithRetryTimeout' +type MockAPIClientWrapped_WithRetryTimeout_Call struct { + *mock.Call +} + +// WithRetryTimeout is a helper method to define mock.On call +// - maxRetries int +// - timeout time.Duration +func (_e *MockAPIClientWrapped_Expecter) WithRetryTimeout(maxRetries any, timeout any) *MockAPIClientWrapped_WithRetryTimeout_Call { + return &MockAPIClientWrapped_WithRetryTimeout_Call{Call: _e.mock.On("WithRetryTimeout", maxRetries, timeout)} +} + +func (_c *MockAPIClientWrapped_WithRetryTimeout_Call) Run(run func(maxRetries int, timeout time.Duration)) *MockAPIClientWrapped_WithRetryTimeout_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 int + if args[0] != nil { + arg0 = args[0].(int) + } + var arg1 time.Duration + if args[1] != nil { + arg1 = args[1].(time.Duration) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockAPIClientWrapped_WithRetryTimeout_Call) Return(aPIClientWrapped ton.APIClientWrapped) *MockAPIClientWrapped_WithRetryTimeout_Call { + _c.Call.Return(aPIClientWrapped) + return _c +} + +func (_c *MockAPIClientWrapped_WithRetryTimeout_Call) RunAndReturn(run func(maxRetries int, timeout time.Duration) ton.APIClientWrapped) *MockAPIClientWrapped_WithRetryTimeout_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) @@ -1816,7 +2973,7 @@ type MockAPIClientWrapped_WithTimeout_Call struct { // WithTimeout is a helper method to define mock.On call // - timeout time.Duration -func (_e *MockAPIClientWrapped_Expecter) WithTimeout(timeout interface{}) *MockAPIClientWrapped_WithTimeout_Call { +func (_e *MockAPIClientWrapped_Expecter) WithTimeout(timeout any) *MockAPIClientWrapped_WithTimeout_Call { return &MockAPIClientWrapped_WithTimeout_Call{Call: _e.mock.On("WithTimeout", timeout)} }