From bdeb8b1eab5a7dc384ce6eeaf305fdeb0a8aaa45 Mon Sep 17 00:00:00 2001 From: lumtis Date: Tue, 11 Feb 2025 17:39:35 +0100 Subject: [PATCH 1/4] use testnet example --- pkg/contracts/sui/gateway.go | 11 ++++++++--- pkg/contracts/sui/gateway_test.go | 6 +++--- 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/pkg/contracts/sui/gateway.go b/pkg/contracts/sui/gateway.go index f581d8b9c7..0e1b0be2ab 100644 --- a/pkg/contracts/sui/gateway.go +++ b/pkg/contracts/sui/gateway.go @@ -5,13 +5,12 @@ import ( _ "embed" "encoding/base64" "fmt" - "github.com/block-vision/sui-go-sdk/models" "github.com/block-vision/sui-go-sdk/sui" "github.com/pkg/errors" ) -// CoinTypeSUI is the coin type for SUI, native gas token +// SUI is the coin type for SUI, native gas token const SUI CoinType = "0000000000000000000000000000000000000000000000000000000000000002::sui::SUI" const ( @@ -32,7 +31,7 @@ type Gateway struct { //go:embed bin/gateway.mv var gatewayBinary []byte -// ErrParse event parse error +// ErrParseEvent event parse error var ErrParseEvent = errors.New("event parse error") // NewGateway creates a new SUI gateway @@ -48,11 +47,13 @@ func GatewayBytecodeBase64() string { } // QueryDepositInbounds queries the inbounds from deposit events from the Sui gateway +// from and to represents time range in Unix time in milliseconds func (g *Gateway) QueryDepositInbounds(ctx context.Context, from, to uint64) ([]Inbound, error) { return g.queryInbounds(ctx, from, to, eventDeposit) } // QueryDepositAndCallInbounds queries the inbounds from depositAndCall events from the Sui gateway +// from and to represents time range in Unix time in milliseconds func (g *Gateway) QueryDepositAndCallInbounds(ctx context.Context, from, to uint64) ([]Inbound, error) { return g.queryInbounds(ctx, from, to, eventDepositAndCall) } @@ -70,6 +71,10 @@ func (g *Gateway) queryInbounds(ctx context.Context, _, _ uint64, event string) // StartTime: from, // EndTime: to, //}, + //"TimeRange": map[string]interface{}{ + //"startTime": from, + //"endTime": to, + //}, "MoveEventType": eventType(g.packageID, moduleName, event), }, Limit: 5, diff --git a/pkg/contracts/sui/gateway_test.go b/pkg/contracts/sui/gateway_test.go index 78426fb2bd..25aea95e44 100644 --- a/pkg/contracts/sui/gateway_test.go +++ b/pkg/contracts/sui/gateway_test.go @@ -13,9 +13,9 @@ import ( // https://github.com/zeta-chain/protocol-contracts-sui?tab=readme-ov-file#integration-test // packageID needs to be set to the value logged as moduleId when running `go run main.go` func TestLiveGateway_ReadInbounds(t *testing.T) { - t.Skip("skipping live test") + //t.Skip("skipping live test") - client := sui.NewSuiClient("http://localhost:9000") + client := sui.NewSuiClient("https://sui-testnet-endpoint.blockvision.org") ctx := context.Background() now := time.Now() @@ -24,7 +24,7 @@ func TestLiveGateway_ReadInbounds(t *testing.T) { gateway := NewGateway( client, - "0xde4e867fd128c42c3dd7b8f79a1e294573e25a976fb4d9697d9fa934f39de0bc", + "0xe88db37ef3dd9f8b334e3839fa277a8d0e37c329b74a965c2c8e802a737885db", ) inbounds, err := gateway.QueryDepositInbounds(ctx, from, uint64(now.UnixMilli())) require.NoError(t, err) From 8cf1119c350a428496b873204ec89f3a4dd6a39c Mon Sep 17 00:00:00 2001 From: lumtis Date: Wed, 12 Feb 2025 11:15:30 +0100 Subject: [PATCH 2/4] parse deposit and call --- pkg/contracts/sui/gateway.go | 1 + pkg/contracts/sui/gateway_test.go | 19 ++++++++++++++----- pkg/contracts/sui/inbound.go | 28 ++++++++++++++++++++++++---- 3 files changed, 39 insertions(+), 9 deletions(-) diff --git a/pkg/contracts/sui/gateway.go b/pkg/contracts/sui/gateway.go index 0e1b0be2ab..35de18c713 100644 --- a/pkg/contracts/sui/gateway.go +++ b/pkg/contracts/sui/gateway.go @@ -5,6 +5,7 @@ import ( _ "embed" "encoding/base64" "fmt" + "github.com/block-vision/sui-go-sdk/models" "github.com/block-vision/sui-go-sdk/sui" "github.com/pkg/errors" diff --git a/pkg/contracts/sui/gateway_test.go b/pkg/contracts/sui/gateway_test.go index 25aea95e44..c4c5b44ce4 100644 --- a/pkg/contracts/sui/gateway_test.go +++ b/pkg/contracts/sui/gateway_test.go @@ -9,11 +9,10 @@ import ( ) // This is a manual live test, uncomment the t.Skip to run it -// Localnet can currently be started and populated by running the instruction at: -// https://github.com/zeta-chain/protocol-contracts-sui?tab=readme-ov-file#integration-test -// packageID needs to be set to the value logged as moduleId when running `go run main.go` +// The test used the gateway deployed on Sui testnet at +// https://suiscan.xyz/testnet/object/0xe88db37ef3dd9f8b334e3839fa277a8d0e37c329b74a965c2c8e802a737885db/tx-blocks func TestLiveGateway_ReadInbounds(t *testing.T) { - //t.Skip("skipping live test") + t.Skip("skipping live test") client := sui.NewSuiClient("https://sui-testnet-endpoint.blockvision.org") ctx := context.Background() @@ -28,5 +27,15 @@ func TestLiveGateway_ReadInbounds(t *testing.T) { ) inbounds, err := gateway.QueryDepositInbounds(ctx, from, uint64(now.UnixMilli())) require.NoError(t, err) - t.Logf("inbounds: %v", inbounds) + t.Logf("deposit:") + for _, inbound := range inbounds { + t.Logf("amount: %d, receiver: %s", inbound.Amount, inbound.Receiver.Hex()) + } + + inbounds, err = gateway.QueryDepositAndCallInbounds(ctx, from, uint64(now.UnixMilli())) + require.NoError(t, err) + t.Logf("depositAndCall:") + for _, inbound := range inbounds { + t.Logf("amount: %d, receiver: %s, payload: %v", inbound.Amount, inbound.Receiver.Hex(), inbound.Payload) + } } diff --git a/pkg/contracts/sui/inbound.go b/pkg/contracts/sui/inbound.go index 30a3015f97..2e24f08222 100644 --- a/pkg/contracts/sui/inbound.go +++ b/pkg/contracts/sui/inbound.go @@ -1,6 +1,7 @@ package sui import ( + "fmt" "strconv" "github.com/block-vision/sui-go-sdk/models" @@ -69,14 +70,16 @@ func parseInbound(event models.SuiEventResponse, eventType string) (Inbound, err return Inbound{}, errors.New("invalid receiver address") } - payload := []byte{} + var payload []byte if eventType == eventDepositAndCall { - parsedPayload, ok := parsedJSON["payload"].(string) + parsedPayload, ok := parsedJSON["payload"].([]interface{}) if !ok { return Inbound{}, errors.New("invalid payload") } - - payload = []byte(parsedPayload) + payload, err = convertPayload(parsedPayload) + if err != nil { + return Inbound{}, errors.Wrap(err, "failed to convert payload") + } } return Inbound{ @@ -89,3 +92,20 @@ func parseInbound(event models.SuiEventResponse, eventType string) (Inbound, err Payload: payload, }, nil } + +// convertPayload +func convertPayload(data []interface{}) ([]byte, error) { + payload := make([]byte, 0, len(data)) + for i, d := range data { + // parsed bytes are represented as float64 + if b, ok := d.(float64); ok { + if b < 0 || b > 255 { + return nil, fmt.Errorf("invalid payload data at index %d, not a byte (%f)", i, b) + } + payload = append(payload, byte(b)) + } else { + return nil, fmt.Errorf("invalid payload data at index %d", i) + } + } + return payload, nil +} From 85537760fcdb24009a7ae94cb33e95be96d6f577 Mon Sep 17 00:00:00 2001 From: lumtis Date: Wed, 12 Feb 2025 14:28:42 +0100 Subject: [PATCH 3/4] initialize tests --- pkg/contracts/sui/gateway.go | 8 +- pkg/contracts/sui/gateway_test.go | 377 +++++- pkg/contracts/sui/inbound.go | 38 +- pkg/contracts/sui/inbound_test.go | 52 + pkg/contracts/sui/mocks/mocks.go | 20 + pkg/contracts/sui/mocks/sui_client.go | 1677 +++++++++++++++++++++++++ 6 files changed, 2148 insertions(+), 24 deletions(-) create mode 100644 pkg/contracts/sui/inbound_test.go create mode 100644 pkg/contracts/sui/mocks/mocks.go create mode 100644 pkg/contracts/sui/mocks/sui_client.go diff --git a/pkg/contracts/sui/gateway.go b/pkg/contracts/sui/gateway.go index 35de18c713..e9b6025107 100644 --- a/pkg/contracts/sui/gateway.go +++ b/pkg/contracts/sui/gateway.go @@ -64,7 +64,8 @@ func (g *Gateway) queryInbounds(ctx context.Context, _, _ uint64, event string) // TODO: Support pagination res, err := g.client.SuiXQueryEvents(ctx, models.SuiXQueryEventsRequest{ SuiEventFilter: map[string]any{ - // TODO: Fix the error + // TODO: Fix the error, or add another solution to query events by time range + // https://github.com/zeta-chain/node/issues/3523 // using TimeRange causes the following error when sending the query: // {"code":-32602,"message":"Invalid params","data":"expected value at line 1 column 108"} // commenting out for new and querying all events @@ -73,12 +74,11 @@ func (g *Gateway) queryInbounds(ctx context.Context, _, _ uint64, event string) // EndTime: to, //}, //"TimeRange": map[string]interface{}{ - //"startTime": from, - //"endTime": to, + // "startTime": from, + // "endTime": to, //}, "MoveEventType": eventType(g.packageID, moduleName, event), }, - Limit: 5, }) if err != nil { return []Inbound{}, err diff --git a/pkg/contracts/sui/gateway_test.go b/pkg/contracts/sui/gateway_test.go index c4c5b44ce4..02de232a85 100644 --- a/pkg/contracts/sui/gateway_test.go +++ b/pkg/contracts/sui/gateway_test.go @@ -1,9 +1,14 @@ -package sui +package sui_test import ( "context" + "errors" + "github.com/block-vision/sui-go-sdk/models" "github.com/block-vision/sui-go-sdk/sui" "github.com/stretchr/testify/require" + zetasui "github.com/zeta-chain/node/pkg/contracts/sui" + "github.com/zeta-chain/node/pkg/contracts/sui/mocks" + "github.com/zeta-chain/node/testutil/sample" "testing" "time" ) @@ -21,7 +26,7 @@ func TestLiveGateway_ReadInbounds(t *testing.T) { // query event from last 2 hours from := uint64(now.Add(-2 * time.Hour).UnixMilli()) - gateway := NewGateway( + gateway := zetasui.NewGateway( client, "0xe88db37ef3dd9f8b334e3839fa277a8d0e37c329b74a965c2c8e802a737885db", ) @@ -30,6 +35,8 @@ func TestLiveGateway_ReadInbounds(t *testing.T) { t.Logf("deposit:") for _, inbound := range inbounds { t.Logf("amount: %d, receiver: %s", inbound.Amount, inbound.Receiver.Hex()) + require.True(t, inbound.IsGasDeposit()) + require.False(t, inbound.IsCrossChainCall) } inbounds, err = gateway.QueryDepositAndCallInbounds(ctx, from, uint64(now.UnixMilli())) @@ -37,5 +44,371 @@ func TestLiveGateway_ReadInbounds(t *testing.T) { t.Logf("depositAndCall:") for _, inbound := range inbounds { t.Logf("amount: %d, receiver: %s, payload: %v", inbound.Amount, inbound.Receiver.Hex(), inbound.Payload) + require.True(t, inbound.IsGasDeposit()) + require.True(t, inbound.IsCrossChainCall) + } +} + +func TestGateway_QueryDepositInbounds(t *testing.T) { + clientMock := mocks.NewSuiClient(t) + gateway := zetasui.NewGateway(clientMock, "packageID") + ctx := context.Background() + + ethAddr1 := sample.EthAddress() + ethAddr2 := sample.EthAddress() + + tt := []struct { + name string + suiQueryRes models.PaginatedEventsResponse + suiQueryErr error + expectedInbounds []zetasui.Inbound + errContains string + }{ + { + name: "no events", + suiQueryRes: models.PaginatedEventsResponse{ + Data: []models.SuiEventResponse{}, + }, + expectedInbounds: []zetasui.Inbound{}, + }, + { + name: "query error", + suiQueryErr: errors.New("query error"), + errContains: "query error", + }, + { + name: "valid events", + suiQueryRes: models.PaginatedEventsResponse{ + Data: []models.SuiEventResponse{ + { + Id: models.EventId{ + TxDigest: "0xabc", + EventSeq: "1", + }, + ParsedJson: map[string]interface{}{ + "coin_type": string(zetasui.SUI), + "amount": "100", + "sender": "0x123", + "receiver": ethAddr1.Hex(), + }, + }, + { + Id: models.EventId{ + TxDigest: "0xefg", + EventSeq: "2", + }, + ParsedJson: map[string]interface{}{ + "coin_type": string(zetasui.SUI), + "amount": "200", + "sender": "0x456", + "receiver": ethAddr2.Hex(), + }, + }, + }, + }, + expectedInbounds: []zetasui.Inbound{ + { + TxHash: "0xabc", + EventIndex: 1, + CoinType: zetasui.SUI, + Amount: 100, + Sender: "0x123", + Receiver: ethAddr1, + IsCrossChainCall: false, + }, + { + TxHash: "0xefg", + EventIndex: 2, + CoinType: zetasui.SUI, + Amount: 200, + Sender: "0x456", + Receiver: ethAddr2, + IsCrossChainCall: false, + }, + }, + }, + { + name: "invalid event index", + suiQueryRes: models.PaginatedEventsResponse{ + Data: []models.SuiEventResponse{ + { + Id: models.EventId{ + TxDigest: "0xabc", + EventSeq: "invalid", + }, + ParsedJson: map[string]interface{}{ + "coin_type": string(zetasui.SUI), + "amount": "100", + "sender": "0x123", + "receiver": ethAddr1.Hex(), + }, + }, + }, + }, + errContains: "failed to parse event index", + }, + { + name: "invalid coin type", + suiQueryRes: models.PaginatedEventsResponse{ + Data: []models.SuiEventResponse{ + { + Id: models.EventId{ + TxDigest: "0xabc", + EventSeq: "1", + }, + ParsedJson: map[string]interface{}{ + "coin_type": 1, + "amount": "100", + "sender": "0x123", + "receiver": ethAddr1.Hex(), + }, + }, + }, + }, + errContains: "invalid coin type", + }, + { + name: "invalid amount", + suiQueryRes: models.PaginatedEventsResponse{ + Data: []models.SuiEventResponse{ + { + Id: models.EventId{ + TxDigest: "0xabc", + EventSeq: "1", + }, + ParsedJson: map[string]interface{}{ + "coin_type": string(zetasui.SUI), + "amount": 100, + "sender": "0x123", + "receiver": ethAddr1.Hex(), + }, + }, + }, + }, + errContains: "invalid amount", + }, + { + name: "invalid sender", + suiQueryRes: models.PaginatedEventsResponse{ + Data: []models.SuiEventResponse{ + { + Id: models.EventId{ + TxDigest: "0xabc", + EventSeq: "1", + }, + ParsedJson: map[string]interface{}{ + "coin_type": string(zetasui.SUI), + "amount": "100", + "sender": 123, + "receiver": ethAddr1.Hex(), + }, + }, + }, + }, + errContains: "invalid sender", + }, + { + name: "invalid receiver", + suiQueryRes: models.PaginatedEventsResponse{ + Data: []models.SuiEventResponse{ + { + Id: models.EventId{ + TxDigest: "0xabc", + EventSeq: "1", + }, + ParsedJson: map[string]interface{}{ + "coin_type": string(zetasui.SUI), + "amount": "100", + "sender": "0x123", + "receiver": 123, + }, + }, + }, + }, + errContains: "invalid receiver", + }, + { + name: "can't parse receiver as evm address", + suiQueryRes: models.PaginatedEventsResponse{ + Data: []models.SuiEventResponse{ + { + Id: models.EventId{ + TxDigest: "0xabc", + EventSeq: "1", + }, + ParsedJson: map[string]interface{}{ + "coin_type": string(zetasui.SUI), + "amount": "100", + "sender": "0x123", + "receiver": "invalid", + }, + }, + }, + }, + errContains: "can't parse receiver address", + }, + } + for _, tc := range tt { + t.Run(tc.name, func(t *testing.T) { + clientMock.MockSuiXQueryEvents(tc.suiQueryRes, tc.suiQueryErr) + inbounds, err := gateway.QueryDepositInbounds(ctx, 0, 0) + if tc.errContains != "" { + require.ErrorContains(t, err, tc.errContains) + return + } + require.NoError(t, err) + require.ElementsMatch(t, tc.expectedInbounds, inbounds) + }) + } +} + +func TestGateway_QueryDepositAndCallInbounds(t *testing.T) { + clientMock := mocks.NewSuiClient(t) + gateway := zetasui.NewGateway(clientMock, "packageID") + ctx := context.Background() + + ethAddr1 := sample.EthAddress() + ethAddr2 := sample.EthAddress() + + tt := []struct { + name string + suiQueryRes models.PaginatedEventsResponse + suiQueryErr error + expectedInbounds []zetasui.Inbound + errContains string + }{ + { + name: "no events", + suiQueryRes: models.PaginatedEventsResponse{ + Data: []models.SuiEventResponse{}, + }, + expectedInbounds: []zetasui.Inbound{}, + }, + { + name: "query error", + suiQueryErr: errors.New("query error"), + errContains: "query error", + }, + { + name: "valid events", + suiQueryRes: models.PaginatedEventsResponse{ + Data: []models.SuiEventResponse{ + { + Id: models.EventId{ + TxDigest: "0xabc", + EventSeq: "1", + }, + ParsedJson: map[string]interface{}{ + "coin_type": string(zetasui.SUI), + "amount": "100", + "sender": "0x123", + "receiver": ethAddr1.Hex(), + "payload": []interface{}{ + float64(1), + float64(2), + float64(3), + }, + }, + }, + { + Id: models.EventId{ + TxDigest: "0xefg", + EventSeq: "2", + }, + ParsedJson: map[string]interface{}{ + "coin_type": string(zetasui.SUI), + "amount": "200", + "sender": "0x456", + "receiver": ethAddr2.Hex(), + "payload": []interface{}{}, + }, + }, + }, + }, + expectedInbounds: []zetasui.Inbound{ + { + TxHash: "0xabc", + EventIndex: 1, + CoinType: zetasui.SUI, + Amount: 100, + Sender: "0x123", + Receiver: ethAddr1, + Payload: []byte{1, 2, 3}, + IsCrossChainCall: true, + }, + { + TxHash: "0xefg", + EventIndex: 2, + CoinType: zetasui.SUI, + Amount: 200, + Sender: "0x456", + Receiver: ethAddr2, + Payload: []byte{}, + IsCrossChainCall: true, + }, + }, + }, + { + name: "invalid payload", + suiQueryRes: models.PaginatedEventsResponse{ + Data: []models.SuiEventResponse{ + { + Id: models.EventId{ + TxDigest: "0xabc", + EventSeq: "2", + }, + ParsedJson: map[string]interface{}{ + "coin_type": string(zetasui.SUI), + "amount": "100", + "sender": "0x123", + "receiver": ethAddr1.Hex(), + "payload": []interface{}{ + float64(1), + uint64(2), + float64(3), + }, + }, + }, + }, + }, + errContains: "failed to convert payload", + }, + { + name: "invalid payload, not a byte", + suiQueryRes: models.PaginatedEventsResponse{ + Data: []models.SuiEventResponse{ + { + Id: models.EventId{ + TxDigest: "0xabc", + EventSeq: "2", + }, + ParsedJson: map[string]interface{}{ + "coin_type": string(zetasui.SUI), + "amount": "100", + "sender": "0x123", + "receiver": ethAddr1.Hex(), + "payload": []interface{}{ + float64(1), + float64(256), + float64(3), + }, + }, + }, + }, + }, + errContains: "failed to convert payload", + }, + } + for _, tc := range tt { + t.Run(tc.name, func(t *testing.T) { + clientMock.MockSuiXQueryEvents(tc.suiQueryRes, tc.suiQueryErr) + inbounds, err := gateway.QueryDepositAndCallInbounds(ctx, 0, 0) + if tc.errContains != "" { + require.ErrorContains(t, err, tc.errContains) + return + } + require.NoError(t, err) + require.ElementsMatch(t, tc.expectedInbounds, inbounds) + }) } } diff --git a/pkg/contracts/sui/inbound.go b/pkg/contracts/sui/inbound.go index 2e24f08222..b137f69e95 100644 --- a/pkg/contracts/sui/inbound.go +++ b/pkg/contracts/sui/inbound.go @@ -14,21 +14,18 @@ type Inbound struct { TxHash string EventIndex uint64 // Note: CoinType is what is used as Asset field in the ForeignCoin object - CoinType CoinType - Amount uint64 - Sender string - Receiver ethcommon.Address - Payload []byte + CoinType CoinType + Amount uint64 + Sender string + Receiver ethcommon.Address + Payload []byte + IsCrossChainCall bool } func (d *Inbound) IsGasDeposit() bool { return d.CoinType == SUI } -func (d *Inbound) IsCrossChainCall() bool { - return len(d.Payload) > 0 -} - // parseInbound parses an inbound from a JSON read in the SUI event // depositAndCall is a flag to indicate if the event is a depositAndCall event otherwise deposit event // TODO: add specific error that can be handled when the event data is invalid @@ -67,11 +64,15 @@ func parseInbound(event models.SuiEventResponse, eventType string) (Inbound, err receiver := ethcommon.HexToAddress(parsedReceiver) if receiver == (ethcommon.Address{}) { - return Inbound{}, errors.New("invalid receiver address") + return Inbound{}, errors.New("can't parse receiver address") } + isCrosschainCall := false + var payload []byte if eventType == eventDepositAndCall { + isCrosschainCall = true + parsedPayload, ok := parsedJSON["payload"].([]interface{}) if !ok { return Inbound{}, errors.New("invalid payload") @@ -83,13 +84,14 @@ func parseInbound(event models.SuiEventResponse, eventType string) (Inbound, err } return Inbound{ - TxHash: event.Id.TxDigest, - EventIndex: eventIndex, - CoinType: CoinType(coinType), - Amount: amount, - Sender: sender, - Receiver: receiver, - Payload: payload, + TxHash: event.Id.TxDigest, + EventIndex: eventIndex, + CoinType: CoinType(coinType), + Amount: amount, + Sender: sender, + Receiver: receiver, + Payload: payload, + IsCrossChainCall: isCrosschainCall, }, nil } @@ -104,7 +106,7 @@ func convertPayload(data []interface{}) ([]byte, error) { } payload = append(payload, byte(b)) } else { - return nil, fmt.Errorf("invalid payload data at index %d", i) + return nil, fmt.Errorf("invalid payload data at index %d, not a float64", i) } } return payload, nil diff --git a/pkg/contracts/sui/inbound_test.go b/pkg/contracts/sui/inbound_test.go new file mode 100644 index 0000000000..19482c6183 --- /dev/null +++ b/pkg/contracts/sui/inbound_test.go @@ -0,0 +1,52 @@ +package sui_test + +import ( + "github.com/stretchr/testify/require" + "github.com/zeta-chain/node/pkg/contracts/sui" + "github.com/zeta-chain/node/testutil/sample" + "testing" +) + +func TestInbound_IsGasDeposit(t *testing.T) { + tests := []struct { + name string + d *sui.Inbound + want bool + }{ + { + name: "gas deposit", + d: &sui.Inbound{ + TxHash: "0x123", + EventIndex: 1, + CoinType: sui.SUI, + Amount: 100, + Sender: "0x456", + Receiver: sample.EthAddress(), + Payload: nil, + }, + want: true, + }, + { + name: "not gas deposit", + d: &sui.Inbound{ + TxHash: "0x123", + EventIndex: 1, + CoinType: "not_sui", + Amount: 100, + Sender: "0x456", + Receiver: sample.EthAddress(), + Payload: nil, + }, + want: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if tt.want { + require.True(t, tt.d.IsGasDeposit()) + } else { + require.False(t, tt.d.IsGasDeposit()) + } + }) + } +} diff --git a/pkg/contracts/sui/mocks/mocks.go b/pkg/contracts/sui/mocks/mocks.go new file mode 100644 index 0000000000..b87cbe0a1e --- /dev/null +++ b/pkg/contracts/sui/mocks/mocks.go @@ -0,0 +1,20 @@ +package mocks + +import ( + "github.com/block-vision/sui-go-sdk/models" + "github.com/block-vision/sui-go-sdk/sui" + "github.com/stretchr/testify/mock" +) + +//go:generate mockery --name SuiClient --filename sui_client.go --case underscore --output . +type SuiClientMock interface { + sui.ISuiAPI +} + +func (m *SuiClient) MockSuiXQueryEvents(res models.PaginatedEventsResponse, err error) { + m.On( + "SuiXQueryEvents", + mock.Anything, + mock.Anything, + ).Return(res, err).Once() +} diff --git a/pkg/contracts/sui/mocks/sui_client.go b/pkg/contracts/sui/mocks/sui_client.go new file mode 100644 index 0000000000..014b8ae9b7 --- /dev/null +++ b/pkg/contracts/sui/mocks/sui_client.go @@ -0,0 +1,1677 @@ +// Code generated by mockery v2.45.0. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + + models "github.com/block-vision/sui-go-sdk/models" +) + +// SuiClient is an autogenerated mock type for the SuiClient type +type SuiClient struct { + mock.Mock +} + +// BatchTransaction provides a mock function with given fields: ctx, req +func (_m *SuiClient) BatchTransaction(ctx context.Context, req models.BatchTransactionRequest) (models.BatchTransactionResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for BatchTransaction") + } + + var r0 models.BatchTransactionResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.BatchTransactionRequest) (models.BatchTransactionResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.BatchTransactionRequest) models.BatchTransactionResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.BatchTransactionResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.BatchTransactionRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MergeCoins provides a mock function with given fields: ctx, req +func (_m *SuiClient) MergeCoins(ctx context.Context, req models.MergeCoinsRequest) (models.TxnMetaData, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for MergeCoins") + } + + var r0 models.TxnMetaData + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.MergeCoinsRequest) (models.TxnMetaData, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.MergeCoinsRequest) models.TxnMetaData); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.MergeCoinsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MoveCall provides a mock function with given fields: ctx, req +func (_m *SuiClient) MoveCall(ctx context.Context, req models.MoveCallRequest) (models.TxnMetaData, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for MoveCall") + } + + var r0 models.TxnMetaData + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.MoveCallRequest) (models.TxnMetaData, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.MoveCallRequest) models.TxnMetaData); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.MoveCallRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Pay provides a mock function with given fields: ctx, req +func (_m *SuiClient) Pay(ctx context.Context, req models.PayRequest) (models.TxnMetaData, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for Pay") + } + + var r0 models.TxnMetaData + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.PayRequest) (models.TxnMetaData, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.PayRequest) models.TxnMetaData); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.PayRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PayAllSui provides a mock function with given fields: ctx, req +func (_m *SuiClient) PayAllSui(ctx context.Context, req models.PayAllSuiRequest) (models.TxnMetaData, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for PayAllSui") + } + + var r0 models.TxnMetaData + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.PayAllSuiRequest) (models.TxnMetaData, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.PayAllSuiRequest) models.TxnMetaData); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.PayAllSuiRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PaySui provides a mock function with given fields: ctx, req +func (_m *SuiClient) PaySui(ctx context.Context, req models.PaySuiRequest) (models.TxnMetaData, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for PaySui") + } + + var r0 models.TxnMetaData + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.PaySuiRequest) (models.TxnMetaData, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.PaySuiRequest) models.TxnMetaData); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.PaySuiRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Publish provides a mock function with given fields: ctx, req +func (_m *SuiClient) Publish(ctx context.Context, req models.PublishRequest) (models.TxnMetaData, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for Publish") + } + + var r0 models.TxnMetaData + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.PublishRequest) (models.TxnMetaData, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.PublishRequest) models.TxnMetaData); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.PublishRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RequestAddStake provides a mock function with given fields: ctx, req +func (_m *SuiClient) RequestAddStake(ctx context.Context, req models.AddStakeRequest) (models.TxnMetaData, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for RequestAddStake") + } + + var r0 models.TxnMetaData + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.AddStakeRequest) (models.TxnMetaData, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.AddStakeRequest) models.TxnMetaData); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.AddStakeRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RequestWithdrawStake provides a mock function with given fields: ctx, req +func (_m *SuiClient) RequestWithdrawStake(ctx context.Context, req models.WithdrawStakeRequest) (models.TxnMetaData, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for RequestWithdrawStake") + } + + var r0 models.TxnMetaData + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.WithdrawStakeRequest) (models.TxnMetaData, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.WithdrawStakeRequest) models.TxnMetaData); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.WithdrawStakeRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SignAndExecuteTransactionBlock provides a mock function with given fields: ctx, req +func (_m *SuiClient) SignAndExecuteTransactionBlock(ctx context.Context, req models.SignAndExecuteTransactionBlockRequest) (models.SuiTransactionBlockResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SignAndExecuteTransactionBlock") + } + + var r0 models.SuiTransactionBlockResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SignAndExecuteTransactionBlockRequest) (models.SuiTransactionBlockResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SignAndExecuteTransactionBlockRequest) models.SuiTransactionBlockResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiTransactionBlockResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SignAndExecuteTransactionBlockRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SplitCoin provides a mock function with given fields: ctx, req +func (_m *SuiClient) SplitCoin(ctx context.Context, req models.SplitCoinRequest) (models.TxnMetaData, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SplitCoin") + } + + var r0 models.TxnMetaData + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SplitCoinRequest) (models.TxnMetaData, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SplitCoinRequest) models.TxnMetaData); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SplitCoinRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SplitCoinEqual provides a mock function with given fields: ctx, req +func (_m *SuiClient) SplitCoinEqual(ctx context.Context, req models.SplitCoinEqualRequest) (models.TxnMetaData, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SplitCoinEqual") + } + + var r0 models.TxnMetaData + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SplitCoinEqualRequest) (models.TxnMetaData, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SplitCoinEqualRequest) models.TxnMetaData); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SplitCoinEqualRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiCall provides a mock function with given fields: ctx, method, params +func (_m *SuiClient) SuiCall(ctx context.Context, method string, params ...interface{}) (interface{}, error) { + var _ca []interface{} + _ca = append(_ca, ctx, method) + _ca = append(_ca, params...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SuiCall") + } + + var r0 interface{} + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) (interface{}, error)); ok { + return rf(ctx, method, params...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) interface{}); ok { + r0 = rf(ctx, method, params...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interface{}) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, ...interface{}) error); ok { + r1 = rf(ctx, method, params...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiDevInspectTransactionBlock provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiDevInspectTransactionBlock(ctx context.Context, req models.SuiDevInspectTransactionBlockRequest) (models.SuiTransactionBlockResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiDevInspectTransactionBlock") + } + + var r0 models.SuiTransactionBlockResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiDevInspectTransactionBlockRequest) (models.SuiTransactionBlockResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiDevInspectTransactionBlockRequest) models.SuiTransactionBlockResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiTransactionBlockResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiDevInspectTransactionBlockRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiDryRunTransactionBlock provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiDryRunTransactionBlock(ctx context.Context, req models.SuiDryRunTransactionBlockRequest) (models.SuiTransactionBlockResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiDryRunTransactionBlock") + } + + var r0 models.SuiTransactionBlockResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiDryRunTransactionBlockRequest) (models.SuiTransactionBlockResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiDryRunTransactionBlockRequest) models.SuiTransactionBlockResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiTransactionBlockResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiDryRunTransactionBlockRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiExecuteTransactionBlock provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiExecuteTransactionBlock(ctx context.Context, req models.SuiExecuteTransactionBlockRequest) (models.SuiTransactionBlockResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiExecuteTransactionBlock") + } + + var r0 models.SuiTransactionBlockResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiExecuteTransactionBlockRequest) (models.SuiTransactionBlockResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiExecuteTransactionBlockRequest) models.SuiTransactionBlockResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiTransactionBlockResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiExecuteTransactionBlockRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiGetChainIdentifier provides a mock function with given fields: ctx +func (_m *SuiClient) SuiGetChainIdentifier(ctx context.Context) (string, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for SuiGetChainIdentifier") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (string, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) string); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiGetCheckpoint provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiGetCheckpoint(ctx context.Context, req models.SuiGetCheckpointRequest) (models.CheckpointResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetCheckpoint") + } + + var r0 models.CheckpointResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiGetCheckpointRequest) (models.CheckpointResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiGetCheckpointRequest) models.CheckpointResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.CheckpointResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiGetCheckpointRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiGetCheckpoints provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiGetCheckpoints(ctx context.Context, req models.SuiGetCheckpointsRequest) (models.PaginatedCheckpointsResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetCheckpoints") + } + + var r0 models.PaginatedCheckpointsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiGetCheckpointsRequest) (models.PaginatedCheckpointsResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiGetCheckpointsRequest) models.PaginatedCheckpointsResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.PaginatedCheckpointsResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiGetCheckpointsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiGetEvents provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiGetEvents(ctx context.Context, req models.SuiGetEventsRequest) (models.GetEventsResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetEvents") + } + + var r0 models.GetEventsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiGetEventsRequest) (models.GetEventsResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiGetEventsRequest) models.GetEventsResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(models.GetEventsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiGetEventsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiGetLatestCheckpointSequenceNumber provides a mock function with given fields: ctx +func (_m *SuiClient) SuiGetLatestCheckpointSequenceNumber(ctx context.Context) (uint64, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for SuiGetLatestCheckpointSequenceNumber") + } + + var r0 uint64 + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (uint64, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) uint64); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(uint64) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiGetLoadedChildObjects provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiGetLoadedChildObjects(ctx context.Context, req models.SuiGetLoadedChildObjectsRequest) (models.ChildObjectsResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetLoadedChildObjects") + } + + var r0 models.ChildObjectsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiGetLoadedChildObjectsRequest) (models.ChildObjectsResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiGetLoadedChildObjectsRequest) models.ChildObjectsResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.ChildObjectsResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiGetLoadedChildObjectsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiGetMoveFunctionArgTypes provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiGetMoveFunctionArgTypes(ctx context.Context, req models.GetMoveFunctionArgTypesRequest) (models.GetMoveFunctionArgTypesResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetMoveFunctionArgTypes") + } + + var r0 models.GetMoveFunctionArgTypesResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.GetMoveFunctionArgTypesRequest) (models.GetMoveFunctionArgTypesResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.GetMoveFunctionArgTypesRequest) models.GetMoveFunctionArgTypesResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(models.GetMoveFunctionArgTypesResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, models.GetMoveFunctionArgTypesRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiGetNormalizedMoveFunction provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiGetNormalizedMoveFunction(ctx context.Context, req models.GetNormalizedMoveFunctionRequest) (models.GetNormalizedMoveFunctionResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetNormalizedMoveFunction") + } + + var r0 models.GetNormalizedMoveFunctionResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.GetNormalizedMoveFunctionRequest) (models.GetNormalizedMoveFunctionResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.GetNormalizedMoveFunctionRequest) models.GetNormalizedMoveFunctionResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.GetNormalizedMoveFunctionResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.GetNormalizedMoveFunctionRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiGetNormalizedMoveModule provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiGetNormalizedMoveModule(ctx context.Context, req models.GetNormalizedMoveModuleRequest) (models.GetNormalizedMoveModuleResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetNormalizedMoveModule") + } + + var r0 models.GetNormalizedMoveModuleResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.GetNormalizedMoveModuleRequest) (models.GetNormalizedMoveModuleResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.GetNormalizedMoveModuleRequest) models.GetNormalizedMoveModuleResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.GetNormalizedMoveModuleResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.GetNormalizedMoveModuleRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiGetNormalizedMoveModulesByPackage provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiGetNormalizedMoveModulesByPackage(ctx context.Context, req models.GetNormalizedMoveModulesByPackageRequest) (models.GetNormalizedMoveModulesByPackageResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetNormalizedMoveModulesByPackage") + } + + var r0 models.GetNormalizedMoveModulesByPackageResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.GetNormalizedMoveModulesByPackageRequest) (models.GetNormalizedMoveModulesByPackageResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.GetNormalizedMoveModulesByPackageRequest) models.GetNormalizedMoveModulesByPackageResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(models.GetNormalizedMoveModulesByPackageResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, models.GetNormalizedMoveModulesByPackageRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiGetNormalizedMoveStruct provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiGetNormalizedMoveStruct(ctx context.Context, req models.GetNormalizedMoveStructRequest) (models.GetNormalizedMoveStructResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetNormalizedMoveStruct") + } + + var r0 models.GetNormalizedMoveStructResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.GetNormalizedMoveStructRequest) (models.GetNormalizedMoveStructResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.GetNormalizedMoveStructRequest) models.GetNormalizedMoveStructResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.GetNormalizedMoveStructResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.GetNormalizedMoveStructRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiGetObject provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiGetObject(ctx context.Context, req models.SuiGetObjectRequest) (models.SuiObjectResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetObject") + } + + var r0 models.SuiObjectResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiGetObjectRequest) (models.SuiObjectResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiGetObjectRequest) models.SuiObjectResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiObjectResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiGetObjectRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiGetProtocolConfig provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiGetProtocolConfig(ctx context.Context, req models.SuiGetProtocolConfigRequest) (models.ProtocolConfigResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetProtocolConfig") + } + + var r0 models.ProtocolConfigResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiGetProtocolConfigRequest) (models.ProtocolConfigResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiGetProtocolConfigRequest) models.ProtocolConfigResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.ProtocolConfigResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiGetProtocolConfigRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiGetTotalTransactionBlocks provides a mock function with given fields: ctx +func (_m *SuiClient) SuiGetTotalTransactionBlocks(ctx context.Context) (uint64, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for SuiGetTotalTransactionBlocks") + } + + var r0 uint64 + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (uint64, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) uint64); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(uint64) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiGetTransactionBlock provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiGetTransactionBlock(ctx context.Context, req models.SuiGetTransactionBlockRequest) (models.SuiTransactionBlockResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiGetTransactionBlock") + } + + var r0 models.SuiTransactionBlockResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiGetTransactionBlockRequest) (models.SuiTransactionBlockResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiGetTransactionBlockRequest) models.SuiTransactionBlockResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiTransactionBlockResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiGetTransactionBlockRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiMultiGetObjects provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiMultiGetObjects(ctx context.Context, req models.SuiMultiGetObjectsRequest) ([]*models.SuiObjectResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiMultiGetObjects") + } + + var r0 []*models.SuiObjectResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiMultiGetObjectsRequest) ([]*models.SuiObjectResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiMultiGetObjectsRequest) []*models.SuiObjectResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*models.SuiObjectResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiMultiGetObjectsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiMultiGetTransactionBlocks provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiMultiGetTransactionBlocks(ctx context.Context, req models.SuiMultiGetTransactionBlocksRequest) (models.SuiMultiGetTransactionBlocksResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiMultiGetTransactionBlocks") + } + + var r0 models.SuiMultiGetTransactionBlocksResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiMultiGetTransactionBlocksRequest) (models.SuiMultiGetTransactionBlocksResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiMultiGetTransactionBlocksRequest) models.SuiMultiGetTransactionBlocksResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(models.SuiMultiGetTransactionBlocksResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiMultiGetTransactionBlocksRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiTryGetPastObject provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiTryGetPastObject(ctx context.Context, req models.SuiTryGetPastObjectRequest) (models.PastObjectResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiTryGetPastObject") + } + + var r0 models.PastObjectResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiTryGetPastObjectRequest) (models.PastObjectResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiTryGetPastObjectRequest) models.PastObjectResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.PastObjectResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiTryGetPastObjectRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiTryMultiGetPastObjects provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiTryMultiGetPastObjects(ctx context.Context, req models.SuiTryMultiGetPastObjectsRequest) ([]*models.PastObjectResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiTryMultiGetPastObjects") + } + + var r0 []*models.PastObjectResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiTryMultiGetPastObjectsRequest) ([]*models.PastObjectResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiTryMultiGetPastObjectsRequest) []*models.PastObjectResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*models.PastObjectResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiTryMultiGetPastObjectsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXGetAllBalance provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiXGetAllBalance(ctx context.Context, req models.SuiXGetAllBalanceRequest) (models.CoinAllBalanceResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetAllBalance") + } + + var r0 models.CoinAllBalanceResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetAllBalanceRequest) (models.CoinAllBalanceResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetAllBalanceRequest) models.CoinAllBalanceResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(models.CoinAllBalanceResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiXGetAllBalanceRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXGetAllCoins provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiXGetAllCoins(ctx context.Context, req models.SuiXGetAllCoinsRequest) (models.PaginatedCoinsResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetAllCoins") + } + + var r0 models.PaginatedCoinsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetAllCoinsRequest) (models.PaginatedCoinsResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetAllCoinsRequest) models.PaginatedCoinsResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.PaginatedCoinsResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiXGetAllCoinsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXGetBalance provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiXGetBalance(ctx context.Context, req models.SuiXGetBalanceRequest) (models.CoinBalanceResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetBalance") + } + + var r0 models.CoinBalanceResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetBalanceRequest) (models.CoinBalanceResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetBalanceRequest) models.CoinBalanceResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.CoinBalanceResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiXGetBalanceRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXGetCoinMetadata provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiXGetCoinMetadata(ctx context.Context, req models.SuiXGetCoinMetadataRequest) (models.CoinMetadataResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetCoinMetadata") + } + + var r0 models.CoinMetadataResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetCoinMetadataRequest) (models.CoinMetadataResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetCoinMetadataRequest) models.CoinMetadataResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.CoinMetadataResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiXGetCoinMetadataRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXGetCoins provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiXGetCoins(ctx context.Context, req models.SuiXGetCoinsRequest) (models.PaginatedCoinsResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetCoins") + } + + var r0 models.PaginatedCoinsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetCoinsRequest) (models.PaginatedCoinsResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetCoinsRequest) models.PaginatedCoinsResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.PaginatedCoinsResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiXGetCoinsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXGetCommitteeInfo provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiXGetCommitteeInfo(ctx context.Context, req models.SuiXGetCommitteeInfoRequest) (models.SuiXGetCommitteeInfoResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetCommitteeInfo") + } + + var r0 models.SuiXGetCommitteeInfoResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetCommitteeInfoRequest) (models.SuiXGetCommitteeInfoResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetCommitteeInfoRequest) models.SuiXGetCommitteeInfoResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiXGetCommitteeInfoResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiXGetCommitteeInfoRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXGetCurrentEpoch provides a mock function with given fields: ctx +func (_m *SuiClient) SuiXGetCurrentEpoch(ctx context.Context) (models.EpochInfo, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetCurrentEpoch") + } + + var r0 models.EpochInfo + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (models.EpochInfo, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) models.EpochInfo); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(models.EpochInfo) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXGetDynamicField provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiXGetDynamicField(ctx context.Context, req models.SuiXGetDynamicFieldRequest) (models.PaginatedDynamicFieldInfoResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetDynamicField") + } + + var r0 models.PaginatedDynamicFieldInfoResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetDynamicFieldRequest) (models.PaginatedDynamicFieldInfoResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetDynamicFieldRequest) models.PaginatedDynamicFieldInfoResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.PaginatedDynamicFieldInfoResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiXGetDynamicFieldRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXGetDynamicFieldObject provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiXGetDynamicFieldObject(ctx context.Context, req models.SuiXGetDynamicFieldObjectRequest) (models.SuiObjectResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetDynamicFieldObject") + } + + var r0 models.SuiObjectResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetDynamicFieldObjectRequest) (models.SuiObjectResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetDynamicFieldObjectRequest) models.SuiObjectResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiObjectResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiXGetDynamicFieldObjectRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXGetEpochs provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiXGetEpochs(ctx context.Context, req models.SuiXGetEpochsRequest) (models.PaginatedEpochInfoResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetEpochs") + } + + var r0 models.PaginatedEpochInfoResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetEpochsRequest) (models.PaginatedEpochInfoResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetEpochsRequest) models.PaginatedEpochInfoResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.PaginatedEpochInfoResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiXGetEpochsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXGetLatestSuiSystemState provides a mock function with given fields: ctx +func (_m *SuiClient) SuiXGetLatestSuiSystemState(ctx context.Context) (models.SuiSystemStateSummary, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetLatestSuiSystemState") + } + + var r0 models.SuiSystemStateSummary + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (models.SuiSystemStateSummary, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) models.SuiSystemStateSummary); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(models.SuiSystemStateSummary) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXGetOwnedObjects provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiXGetOwnedObjects(ctx context.Context, req models.SuiXGetOwnedObjectsRequest) (models.PaginatedObjectsResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetOwnedObjects") + } + + var r0 models.PaginatedObjectsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetOwnedObjectsRequest) (models.PaginatedObjectsResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetOwnedObjectsRequest) models.PaginatedObjectsResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.PaginatedObjectsResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiXGetOwnedObjectsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXGetReferenceGasPrice provides a mock function with given fields: ctx +func (_m *SuiClient) SuiXGetReferenceGasPrice(ctx context.Context) (uint64, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetReferenceGasPrice") + } + + var r0 uint64 + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (uint64, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) uint64); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(uint64) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXGetStakes provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiXGetStakes(ctx context.Context, req models.SuiXGetStakesRequest) ([]*models.DelegatedStakesResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetStakes") + } + + var r0 []*models.DelegatedStakesResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetStakesRequest) ([]*models.DelegatedStakesResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetStakesRequest) []*models.DelegatedStakesResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*models.DelegatedStakesResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiXGetStakesRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXGetStakesByIds provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiXGetStakesByIds(ctx context.Context, req models.SuiXGetStakesByIdsRequest) ([]*models.DelegatedStakesResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetStakesByIds") + } + + var r0 []*models.DelegatedStakesResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetStakesByIdsRequest) ([]*models.DelegatedStakesResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetStakesByIdsRequest) []*models.DelegatedStakesResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*models.DelegatedStakesResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiXGetStakesByIdsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXGetTotalSupply provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiXGetTotalSupply(ctx context.Context, req models.SuiXGetTotalSupplyRequest) (models.TotalSupplyResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetTotalSupply") + } + + var r0 models.TotalSupplyResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetTotalSupplyRequest) (models.TotalSupplyResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXGetTotalSupplyRequest) models.TotalSupplyResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.TotalSupplyResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiXGetTotalSupplyRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXGetValidatorsApy provides a mock function with given fields: ctx +func (_m *SuiClient) SuiXGetValidatorsApy(ctx context.Context) (models.ValidatorsApy, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for SuiXGetValidatorsApy") + } + + var r0 models.ValidatorsApy + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (models.ValidatorsApy, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) models.ValidatorsApy); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(models.ValidatorsApy) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXQueryEvents provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiXQueryEvents(ctx context.Context, req models.SuiXQueryEventsRequest) (models.PaginatedEventsResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXQueryEvents") + } + + var r0 models.PaginatedEventsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXQueryEventsRequest) (models.PaginatedEventsResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXQueryEventsRequest) models.PaginatedEventsResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.PaginatedEventsResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiXQueryEventsRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXQueryTransactionBlocks provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiXQueryTransactionBlocks(ctx context.Context, req models.SuiXQueryTransactionBlocksRequest) (models.SuiXQueryTransactionBlocksResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXQueryTransactionBlocks") + } + + var r0 models.SuiXQueryTransactionBlocksResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXQueryTransactionBlocksRequest) (models.SuiXQueryTransactionBlocksResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXQueryTransactionBlocksRequest) models.SuiXQueryTransactionBlocksResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiXQueryTransactionBlocksResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiXQueryTransactionBlocksRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXResolveNameServiceAddress provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiXResolveNameServiceAddress(ctx context.Context, req models.SuiXResolveNameServiceAddressRequest) (string, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXResolveNameServiceAddress") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXResolveNameServiceAddressRequest) (string, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXResolveNameServiceAddressRequest) string); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiXResolveNameServiceAddressRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SuiXResolveNameServiceNames provides a mock function with given fields: ctx, req +func (_m *SuiClient) SuiXResolveNameServiceNames(ctx context.Context, req models.SuiXResolveNameServiceNamesRequest) (models.SuiXResolveNameServiceNamesResponse, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for SuiXResolveNameServiceNames") + } + + var r0 models.SuiXResolveNameServiceNamesResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXResolveNameServiceNamesRequest) (models.SuiXResolveNameServiceNamesResponse, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.SuiXResolveNameServiceNamesRequest) models.SuiXResolveNameServiceNamesResponse); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.SuiXResolveNameServiceNamesResponse) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.SuiXResolveNameServiceNamesRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TransferObject provides a mock function with given fields: ctx, req +func (_m *SuiClient) TransferObject(ctx context.Context, req models.TransferObjectRequest) (models.TxnMetaData, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for TransferObject") + } + + var r0 models.TxnMetaData + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.TransferObjectRequest) (models.TxnMetaData, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.TransferObjectRequest) models.TxnMetaData); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.TransferObjectRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// TransferSui provides a mock function with given fields: ctx, req +func (_m *SuiClient) TransferSui(ctx context.Context, req models.TransferSuiRequest) (models.TxnMetaData, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for TransferSui") + } + + var r0 models.TxnMetaData + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, models.TransferSuiRequest) (models.TxnMetaData, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, models.TransferSuiRequest) models.TxnMetaData); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Get(0).(models.TxnMetaData) + } + + if rf, ok := ret.Get(1).(func(context.Context, models.TransferSuiRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// NewSuiClient creates a new instance of SuiClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewSuiClient(t interface { + mock.TestingT + Cleanup(func()) +}) *SuiClient { + mock := &SuiClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} From e84bf2ceab73dbe7231345296bd9a2d2da58091a Mon Sep 17 00:00:00 2001 From: lumtis Date: Wed, 12 Feb 2025 14:30:54 +0100 Subject: [PATCH 4/4] revert changelogs change --- changelog.md | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/changelog.md b/changelog.md index 6477161c63..4a2a0da9f9 100644 --- a/changelog.md +++ b/changelog.md @@ -4,12 +4,18 @@ ### Features -* [3461](https://github.com/zeta-chain/node/pull/3461) - add new 'ConfirmationParams' field to chain params to enable multiple confirmation count values, deprecating `confirmation_count` +* [3461](https://github.com/zeta-chain/node/pull/3461) - add new `ConfirmationParams` field to chain params to enable multiple confirmation count values, deprecating `confirmation_count` +* [3489](https://github.com/zeta-chain/node/pull/3489) - add Sui chain info +* [3455](https://github.com/zeta-chain/node/pull/3455) - add `track-cctx` command to zetatools ### Refactor * [3381](https://github.com/zeta-chain/node/pull/3381) - split Bitcoin observer and signer into small files and organize outbound logic into reusable/testable functions; renaming, type unification, etc. +### Fixes + +* [3501](https://github.com/zeta-chain/node/pull/3501) - fix E2E test failure caused by nil `ConfirmationParams` for Solana and TON + ### Tests * [3430](https://github.com/zeta-chain/node/pull/3430) - add simulation test for MsgWithDrawEmission