[OTE-221] Add query for PendingSendPacket

proto/dydxprotocol/ratelimit/pending_send_packet.proto

@@ -0,0 +1,11 @@
+syntax = "proto3";
+package dydxprotocol.ratelimit;
+
+option go_package = "github.com/dydxprotocol/v4-chain/protocol/x/ratelimit/types";
+
+// PendingSendPacket contains the channel_id and sequence pair to identify a
+// pending packet
+message PendingSendPacket {
+  string channel_id = 1;
+  uint64 sequence = 2;
+}

proto/dydxprotocol/ratelimit/query.proto

@@ -5,6 +5,7 @@ import "gogoproto/gogo.proto";
 import "google/api/annotations.proto";
 import "dydxprotocol/ratelimit/limit_params.proto";
 import "dydxprotocol/ratelimit/capacity.proto";
+import "dydxprotocol/ratelimit/pending_send_packet.proto";
 
 option go_package = "github.com/dydxprotocol/v4-chain/protocol/x/ratelimit/types";
 
@@ -23,6 +24,12 @@ service Query {
     option (google.api.http).get =
         "/dydxprotocol/v4/ratelimit/capacity_by_denom";
   }
+  // Get all pending send packets
+  rpc AllPendingSendPackets(QueryAllPendingSendPacketsRequest)
+      returns (QueryAllPendingSendPacketsResponse) {
+    option (google.api.http).get =
+        "/dydxprotocol/v4/ratelimit/get_all_pending_send_packet";
+  }
 }
 
 // ListLimitParamsRequest is a request type of the ListLimitParams RPC method.
@@ -43,3 +50,14 @@ message QueryCapacityByDenomResponse {
   repeated LimiterCapacity limiter_capacity_list = 1
       [ (gogoproto.nullable) = false ];
 }
+
+// QueryAllPendingSendPacketsRequest is a request type for the
+// AllPendingSendPackets RPC
+message QueryAllPendingSendPacketsRequest {}
+
+// QueryAllPendingSendPacketsResponse is a response type of the
+// AllPendingSendPackets RPC
+message QueryAllPendingSendPacketsResponse {
+  repeated PendingSendPacket pending_send_packets = 1
+      [ (gogoproto.nullable) = false ];
+}

protocol/go.mod

@@ -71,6 +71,7 @@ require (
 	github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d
 	google.golang.org/genproto/googleapis/api v0.0.0-20231212172506-995d672761c0
 	google.golang.org/protobuf v1.32.0
+	gotest.tools/v3 v3.5.1
 )
 
 require (
@@ -405,7 +406,6 @@ require (
 	gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
-	gotest.tools/v3 v3.5.1 // indirect
 	honnef.co/go/tools v0.4.6 // indirect
 	mvdan.cc/gofumpt v0.6.0 // indirect
 	mvdan.cc/interfacer v0.0.0-20180901003855-c20040233aed // indirect

protocol/x/ratelimit/client/cli/pending_send_packets.go

@@ -0,0 +1,35 @@
+package cli
+
+import (
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/dydxprotocol/v4-chain/protocol/x/ratelimit/types"
+	"github.com/spf13/cobra"
+)
+
+func CmdPendingSendPackets() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "pending-send-packets",
+		Short: "gets all pending send packets",
+		Args:  cobra.ExactArgs(0),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			queryClient := types.NewQueryClient(clientCtx)
+
+			res, err := queryClient.AllPendingSendPackets(cmd.Context(), &types.QueryAllPendingSendPacketsRequest{})
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+
+	return cmd
+}

protocol/x/ratelimit/client/cli/pending_send_packets_test.go

@@ -0,0 +1,30 @@
+//go:build all || integration_test
+
+package cli_test
+
+import (
+	"fmt"
+	"testing"
+
+	tmcli "github.com/cometbft/cometbft/libs/cli"
+	clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
+	"github.com/dydxprotocol/v4-chain/protocol/x/ratelimit/client/cli"
+	"github.com/dydxprotocol/v4-chain/protocol/x/ratelimit/types"
+	"github.com/stretchr/testify/require"
+	"gotest.tools/v3/assert"
+)
+
+func TestPendingSendPackets(t *testing.T) {
+	net, ctx := setupNetwork(t)
+
+	out, err := clitestutil.ExecTestCLICmd(ctx,
+		cli.CmdPendingSendPackets(),
+		[]string{
+			fmt.Sprintf("--%s=json", tmcli.OutputFlag),
+		})
+
+	require.NoError(t, err)
+	var resp types.QueryAllPendingSendPacketsResponse
+	require.NoError(t, net.Config.Codec.UnmarshalJSON(out.Bytes(), &resp))
+	assert.Equal(t, 0, len(resp.PendingSendPackets))
+}

protocol/x/ratelimit/client/cli/query.go

@@ -22,6 +22,7 @@ func GetQueryCmd(queryRoute string) *cobra.Command {
 
 	cmd.AddCommand(CmdListLimitParams())
 	cmd.AddCommand(CmdQueryCapacityByDenom())
+	cmd.AddCommand(CmdPendingSendPackets())
 
 	return cmd
 }

protocol/x/ratelimit/keeper/grpc_query.go

@@ -3,7 +3,9 @@ package keeper
 import (
 	"context"
 
+	"cosmossdk.io/store/prefix"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/dydxprotocol/v4-chain/protocol/lib/log"
 	"github.com/dydxprotocol/v4-chain/protocol/x/ratelimit/types"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
@@ -47,3 +49,32 @@ func (k Keeper) CapacityByDenom(
 		LimiterCapacityList: limiterCapacityList,
 	}, nil
 }
+
+func (k Keeper) AllPendingSendPackets(
+	ctx context.Context,
+	req *types.QueryAllPendingSendPacketsRequest,
+) (*types.QueryAllPendingSendPacketsResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid request")
+	}
+	sdkCtx := sdk.UnwrapSDKContext(ctx)
+
+	store := prefix.NewStore(sdkCtx.KVStore(k.storeKey), []byte(types.PendingSendPacketPrefix))
+	pendingPackets := make([]types.PendingSendPacket, 0)
+	iterator := store.Iterator(nil, nil)
+	defer iterator.Close()
+	for ; iterator.Valid(); iterator.Next() {
+		channelId, sequence, err := types.SplitPendingSendPacketKey(iterator.Key())
+		if err != nil {
+			log.ErrorLog(sdkCtx, "unexpected PendingSendPacket key format", err)
+			return nil, err
+		}
+		pendingPackets = append(pendingPackets, types.PendingSendPacket{
+			ChannelId: channelId,
+			Sequence:  sequence,
+		})
+	}
+	return &types.QueryAllPendingSendPacketsResponse{
+		PendingSendPackets: pendingPackets,
+	}, nil
+}

protocol/x/ratelimit/keeper/grpc_query_test.go

@@ -139,3 +139,32 @@ func TestCapacityByDenom(t *testing.T) {
 		})
 	}
 }
+
+func TestGetAllPendingSendPacket(t *testing.T) {
+	tApp := testapp.NewTestAppBuilder(t).Build()
+	ctx := tApp.InitChain()
+	k := tApp.App.RatelimitKeeper
+
+	channels := []string{"channel-0", "channel-1"}
+	sequences := []uint64{20, 22}
+
+	for i := range channels {
+		k.SetPendingSendPacket(ctx, channels[i], sequences[i])
+	}
+
+	req := &types.QueryAllPendingSendPacketsRequest{}
+	res, err := k.AllPendingSendPackets(ctx, req)
+	require.NoError(t, err)
+	require.Equal(t, &types.QueryAllPendingSendPacketsResponse{
+		PendingSendPackets: []types.PendingSendPacket{
+			{
+				ChannelId: channels[0],
+				Sequence:  sequences[0],
+			},
+			{
+				ChannelId: channels[1],
+				Sequence:  sequences[1],
+			},
+		},
+	}, res)
+}

protocol/x/ratelimit/module_test.go

@@ -132,7 +132,8 @@ func TestAppModuleBasic_GetQueryCmd(t *testing.T) {
 
 	cmd := am.GetQueryCmd()
 	require.Equal(t, "ratelimit", cmd.Use)
-	require.Equal(t, 2, len(cmd.Commands()))
+	require.Equal(t, 3, len(cmd.Commands()))
 	require.Equal(t, "capacity-by-denom", cmd.Commands()[0].Name())
 	require.Equal(t, "list-limit-params", cmd.Commands()[1].Name())
+	require.Equal(t, "pending-send-packets", cmd.Commands()[2].Name())
 }

protocol/x/ratelimit/types/keys.go

@@ -1,6 +1,10 @@
 package types
 
-import fmt "fmt"
+import (
+	"bytes"
+	"fmt"
+	"strconv"
+)
 
 // Module name and store keys
 const (
@@ -27,3 +31,18 @@ const ()
 func GetPendingSendPacketKey(channelId string, sequenceNumber uint64) []byte {
 	return []byte(fmt.Sprintf("%s_%d", channelId, sequenceNumber))
 }
+
+func SplitPendingSendPacketKey(key []byte) (channelId string, sequenceNumber uint64, err error) {
+	err = nil
+	parts := bytes.Split(key, []byte("_"))
+	if len(parts) != 2 {
+		err = fmt.Errorf("unexpected PendingSendPacket key format: %s", key)
+		return
+	}
+	channelId = string(parts[0])
+	// convert parts[1] to uint64 parts[1] is is a byte array with numeric characters of variable length
+
+	sequenceNumberInt, _ := strconv.Atoi(string(parts[1]))
+	sequenceNumber = uint64(sequenceNumberInt)
+	return
+}

protocol/x/ratelimit/types/keys_test.go

@@ -16,3 +16,14 @@ func TestStateKeys(t *testing.T) {
 	require.Equal(t, "DenomCapacity:", types.DenomCapacityKeyPrefix)
 	require.Equal(t, "LimitParams:", types.LimitParamsKeyPrefix)
 }
+
+func TestSplitPendingSendPacketKey(t *testing.T) {
+	channelId := "channel-0"
+	sequenceNumber := uint64(2)
+	channelIdReceived, sequenceNumberReceived, err := types.SplitPendingSendPacketKey(
+		types.GetPendingSendPacketKey(channelId, sequenceNumber),
+	)
+	require.NoError(t, err)
+	require.Equal(t, channelId, channelIdReceived)
+	require.Equal(t, sequenceNumber, sequenceNumberReceived)
+}