@agoric/cosmos 0.35.0-upgrade-14-dev-c8f9e7b.0 → 0.35.0-upgrade-16a-dev-fb592e4.0

package/x/vlocalchain/vlocalchain.go

@@ -0,0 +1,114 @@
+package vlocalchain
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vlocalchain/keeper"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vlocalchain/types"
+)
+
+var _ vm.PortHandler = (*portHandler)(nil)
+
+type portHandler struct {
+	keeper keeper.Keeper
+}
+
+type portMessage struct {
+	Type     string          `json:"type"`
+	Address  string          `json:"address,omitempty"`
+	Messages json.RawMessage `json:"messages,omitempty"`
+}
+
+func NewReceiver(keeper keeper.Keeper) portHandler {
+	return portHandler{keeper: keeper}
+}
+
+func (h portHandler) Receive(cctx context.Context, str string) (ret string, err error) {
+	var msg portMessage
+	err = json.Unmarshal([]byte(str), &msg)
+	if err != nil {
+		return
+	}
+
+	switch msg.Type {
+	case "VLOCALCHAIN_ALLOCATE_ADDRESS":
+		addr := h.keeper.AllocateAddress(cctx)
+		var bz []byte
+		if bz, err = json.Marshal(addr.String()); err != nil {
+			return
+		}
+		ret = string(bz)
+
+	case "VLOCALCHAIN_QUERY_MANY":
+		// Copy the JSON messages string into a CosmosTx object so we can
+		// deserialize it with just proto3 JSON.
+		cosmosTxBz := []byte(`{"messages":` + string(msg.Messages) + `}`)
+
+		var qms []types.QueryRequest
+		qms, err = h.keeper.DeserializeRequests(cosmosTxBz)
+		if err != nil {
+			return
+		}
+
+		var errs []error
+		resps := make([]interface{}, len(qms))
+		for i, qm := range qms {
+			var qr *types.QueryResponse
+			qr, err = h.keeper.Query(cctx, qm)
+			if err == nil {
+				// Only fill out the response if the query was successful.
+				resps[i] = qr
+			} else {
+				errs = append(errs, err) // Accumulate errors
+				resps[i] = &types.QueryResponse{Error: err.Error()}
+			}
+		}
+
+		bz, err := vm.ProtoJSONMarshalSlice(resps)
+		if err != nil {
+			return "", err
+		}
+
+		switch len(errs) {
+		case 0:
+			err = nil
+		case 1:
+			err = errs[0]
+		case len(resps):
+			err = fmt.Errorf("all queries in batch failed: %v", errs)
+		default:
+			// Let them inspect the individual errors manually.
+		}
+		return string(bz), err
+
+	case "VLOCALCHAIN_EXECUTE_TX":
+		origCtx := sdk.UnwrapSDKContext(cctx)
+
+		// Copy the JSON messages string into a CosmosTx object so we can
+		// deserialize it with just proto3 JSON.
+		cosmosTxBz := []byte(`{"messages":` + string(msg.Messages) + `}`)
+
+		var msgs []sdk.Msg
+		if msgs, err = h.keeper.DeserializeTxMessages(cosmosTxBz); err != nil {
+			return
+		}
+
+		var resps []interface{}
+		resps, err = h.keeper.ExecuteTx(origCtx, msg.Address, msgs)
+		if err != nil {
+			return
+		}
+
+		// Marshal the responses to proto3 JSON.
+		bz, e := vm.ProtoJSONMarshalSlice(resps)
+		return string(bz), e
+	default:
+		err = fmt.Errorf("unrecognized message type %s", msg.Type)
+	}
+	return
+}

package/x/vlocalchain/vlocalchain_test.go

@@ -0,0 +1,434 @@
+package vlocalchain_test
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/app/params"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vlocalchain"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vlocalchain/types"
+
+	"github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/store"
+	storetypes "github.com/cosmos/cosmos-sdk/store/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+	transfertypes "github.com/cosmos/ibc-go/v6/modules/apps/transfer/types"
+	"github.com/tendermint/tendermint/libs/log"
+
+	"github.com/gogo/protobuf/jsonpb"
+	"github.com/gogo/protobuf/proto"
+	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+	dbm "github.com/tendermint/tm-db"
+)
+
+var (
+	vlocalchainStoreKey = sdk.NewKVStoreKey(types.StoreKey)
+)
+
+const (
+	firstAddr          = "cosmos1uupflqrldlpkktssnzgp3r03ff6kz4u4kzd92pjgsfddye7grrlqt9rmmt"
+	msgAllocateAddress = `{"type":"VLOCALCHAIN_ALLOCATE_ADDRESS"}`
+)
+
+type mockBank struct {
+	banktypes.UnimplementedQueryServer
+	banktypes.UnimplementedMsgServer
+	balances   map[string]sdk.Coins
+	failToSend error
+}
+
+var _ banktypes.QueryServer = (*mockBank)(nil)
+var _ banktypes.MsgServer = (*mockBank)(nil)
+
+func (b *mockBank) AllBalances(cctx context.Context, req *banktypes.QueryAllBalancesRequest) (*banktypes.QueryAllBalancesResponse, error) {
+	addr, err := sdk.AccAddressFromBech32(req.Address)
+	if err != nil {
+		return nil, err
+	}
+
+	var resp banktypes.QueryAllBalancesResponse
+	resp.Balances = sdk.Coins{}
+	if coins, ok := b.balances[addr.String()]; ok {
+		resp.Balances = coins
+	}
+	return &resp, nil
+}
+
+func (b *mockBank) Send(cctx context.Context, req *banktypes.MsgSend) (*banktypes.MsgSendResponse, error) {
+	if b.failToSend != nil {
+		return nil, b.failToSend
+	}
+	return &banktypes.MsgSendResponse{}, nil
+}
+
+type mockTransfer struct {
+	transfertypes.UnimplementedQueryServer
+	transfertypes.UnimplementedMsgServer
+}
+
+var _ transfertypes.QueryServer = (*mockTransfer)(nil)
+var _ transfertypes.MsgServer = (*mockTransfer)(nil)
+
+func (t *mockTransfer) Transfer(cctx context.Context, msg *transfertypes.MsgTransfer) (*transfertypes.MsgTransferResponse, error) {
+	return &transfertypes.MsgTransferResponse{Sequence: 1}, nil
+}
+
+type mockStaking struct {
+	stakingtypes.UnimplementedMsgServer
+	stakingtypes.UnimplementedQueryServer
+}
+
+var _ stakingtypes.MsgServer = (*mockStaking)(nil)
+var _ stakingtypes.QueryServer = (*mockStaking)(nil)
+
+func (s *mockStaking) Undelegate(cctx context.Context, msg *stakingtypes.MsgUndelegate) (*stakingtypes.MsgUndelegateResponse, error) {
+	return &stakingtypes.MsgUndelegateResponse{CompletionTime: time.Now().UTC()}, nil
+}
+
+func (s *mockStaking) UnbondingDelegation(cctx context.Context, req *stakingtypes.QueryUnbondingDelegationRequest) (*stakingtypes.QueryUnbondingDelegationResponse, error) {
+	unbondingDelegation := stakingtypes.UnbondingDelegation{
+		DelegatorAddress: req.DelegatorAddr,
+		ValidatorAddress: "cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj",
+		Entries: []stakingtypes.UnbondingDelegationEntry{
+			{
+				CreationHeight: 100,
+				CompletionTime: time.Now().UTC().Add(time.Hour * 24 * 7),
+				InitialBalance: sdk.NewInt(1000),
+				Balance:        sdk.NewInt(500),
+			},
+		},
+	}
+	return &stakingtypes.QueryUnbondingDelegationResponse{Unbond: unbondingDelegation}, nil
+}
+
+// makeTestKit creates a minimal Keeper and Context for use in testing.
+func makeTestKit(bank *mockBank, transfer *mockTransfer, staking *mockStaking) (vm.PortHandler, context.Context) {
+	encodingConfig := params.MakeEncodingConfig()
+	cdc := encodingConfig.Marshaler
+
+	txRouter := baseapp.NewMsgServiceRouter()
+	txRouter.SetInterfaceRegistry(encodingConfig.InterfaceRegistry)
+	queryRouter := baseapp.NewGRPCQueryRouter()
+	queryRouter.SetInterfaceRegistry(encodingConfig.InterfaceRegistry)
+
+	banktypes.RegisterInterfaces(encodingConfig.InterfaceRegistry)
+	banktypes.RegisterMsgServer(txRouter, bank)
+	banktypes.RegisterQueryServer(queryRouter, bank)
+	transfertypes.RegisterInterfaces(encodingConfig.InterfaceRegistry)
+	transfertypes.RegisterMsgServer(txRouter, transfer)
+	transfertypes.RegisterQueryServer(queryRouter, transfer)
+	stakingtypes.RegisterInterfaces(encodingConfig.InterfaceRegistry)
+	stakingtypes.RegisterMsgServer(txRouter, staking)
+	stakingtypes.RegisterQueryServer(queryRouter, staking)
+
+
+	// create a new Keeper
+	keeper := vlocalchain.NewKeeper(cdc, vlocalchainStoreKey, txRouter, queryRouter)
+
+	db := dbm.NewMemDB()
+	ms := store.NewCommitMultiStore(db)
+	ms.MountStoreWithDB(vlocalchainStoreKey, storetypes.StoreTypeIAVL, db)
+	err := ms.LoadLatestVersion()
+	if err != nil {
+		panic(err)
+	}
+
+	// create a new SDK Context
+	ctx := sdk.NewContext(ms, tmproto.Header{}, false, log.NewNopLogger()).WithBlockHeight(998)
+
+	handler := vm.NewProtectedPortHandler(vlocalchain.NewReceiver(keeper))
+
+	// create a new Go context
+	cctx := sdk.WrapSDKContext(ctx)
+	return handler, cctx
+}
+
+func TestAllocateAddress(t *testing.T) {
+	bank := &mockBank{}
+	transfer := &mockTransfer{}
+	staking := &mockStaking{}
+	handler, cctx := makeTestKit(bank, transfer, staking)
+
+	addrs := map[string]bool{
+		firstAddr: false,
+		"cosmos1yj40fakym8kf4wvgz9tky7k9f3v9msm3t7frscrmkjsdkxkpsfkqgeczkg": false,
+		"cosmos1s76vryj7m8k8nm9le65a4plhf5rym5sumtt2n0vwnk5l6k4cwuhsj56ujj": false,
+		"cosmos1c5hplwyxk5jr2dsygjqepzfqvfukwduq9c4660aah76krf99m6gs0k7hvl": false,
+		"cosmos1ys3a7mtna3cad0wxcs4ddukn37stexjdvns8jfdn4uerlr95y4xqnrypf6": false,
+	}
+	numToTest := len(addrs)
+	for i := 0; i < numToTest; i++ {
+		// receive the message
+		ret, err := handler.Receive(cctx, msgAllocateAddress)
+		if err != nil {
+			t.Fatalf("unexpected error[%d]: %v", i, err)
+		}
+		if ret == "" {
+			t.Fatalf("expected non-empty address[%d]", i)
+		}
+		var addr string
+		if err := json.Unmarshal([]byte(ret), &addr); err != nil {
+			t.Fatalf("unexpected error unmarshalling address string[%d]: %v: %v", i, ret, err)
+		}
+
+		already, ok := addrs[addr]
+		if !ok {
+			t.Fatalf("unexpected address[%d]: %v", i, addr)
+		}
+		if already {
+			t.Fatalf("unexpected duplicate address[%d]: %v", i, addr)
+		}
+		addrs[addr] = true
+	}
+}
+
+func TestQuery(t *testing.T) {
+	alreadyAddr := sdk.MustBech32ifyAddressBytes("cosmos", []byte("already"))
+	nonexistentAddr := sdk.MustBech32ifyAddressBytes("cosmos", []byte("nonexistent"))
+	bank := &mockBank{balances: map[string]sdk.Coins{
+		firstAddr:   []sdk.Coin{sdk.NewCoin("fresh", sdk.NewInt(123))},
+		alreadyAddr: []sdk.Coin{sdk.NewCoin("stale", sdk.NewInt(321))},
+	}}
+	transfer := &mockTransfer{}
+	staking := &mockStaking{}
+	handler, cctx := makeTestKit(bank, transfer, staking)
+
+	// get balances
+	testCases := []struct {
+		name     string
+		addr     string
+		failure  string
+		expected sdk.Coins
+	}{
+		{"nonexistent", nonexistentAddr, "", sdk.Coins{}},
+		{"already", alreadyAddr, "", bank.balances[alreadyAddr]},
+		{"first", firstAddr, "", bank.balances[firstAddr]},
+		{"badaddr", "cosmos11111111111", "decoding bech32 failed: invalid separator index 16", sdk.Coins{}},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		ctx := sdk.UnwrapSDKContext(cctx)
+		t.Run(tc.name, func(t *testing.T) {
+			msgGetBalances := `{"type":"VLOCALCHAIN_QUERY_MANY","messages":[{"@type":"/cosmos.bank.v1beta1.QueryAllBalancesRequest","address":"` + tc.addr + `"}]}`
+			t.Logf("query request: %v", msgGetBalances)
+			ret, err := handler.Receive(cctx, msgGetBalances)
+			t.Logf("query response: %v", ret)
+			if tc.failure != "" {
+				if err == nil {
+					t.Fatalf("expected error %v, not nil with return %v", tc.failure, ret)
+				} else if err.Error() != tc.failure {
+					t.Fatalf("expected error %v, not %v", tc.failure, err)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if err == nil && ret == "" {
+				t.Fatalf("expected non-empty json")
+			}
+
+			// Unmarshal the responses.
+			s := `{"responses":` + ret + `}`
+
+			unmarshaler := jsonpb.Unmarshaler{}
+			var qrs types.QueryResponses
+			if err = unmarshaler.Unmarshal(strings.NewReader(s), &qrs); err != nil {
+				t.Fatalf("unexpected error unmarshalling reply: %v: %v", ret, err)
+			}
+
+			resps := qrs.Responses
+			if len(resps) != 1 {
+				t.Fatalf("expected responses length 1, got %v", len(resps))
+			}
+			if resps[0].Error != "" {
+				t.Fatalf("unexpected error response: %v", resps[0].Error)
+			}
+			if resps[0].Height != ctx.BlockHeight() {
+				t.Fatalf("expected height %v, got %v", ctx.BlockHeight(), resps[0].Height)
+			}
+
+			// Unmarshal the Any.
+			var pb banktypes.QueryAllBalancesResponse
+			if err = proto.Unmarshal(resps[0].Reply.Value, &pb); err != nil {
+				t.Fatalf("unexpected error unmarshalling reply: %v: %v", ret, err)
+			}
+
+			if !pb.Balances.IsEqual(tc.expected) {
+				t.Errorf("unexpected balance: expected %v, got %v", tc.expected, pb.Balances)
+			}
+		})
+	}
+
+	t.Run("UnbondingDelegation", func(t *testing.T) {
+		// create a new message
+		msg := `{"type":"VLOCALCHAIN_QUERY_MANY","messages":[{"@type":"/cosmos.staking.v1beta1.QueryUnbondingDelegationRequest","delegator_addr":"` + firstAddr + `","validator_addr":"cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj"}]}`
+		t.Logf("query request: %v", msg)
+		ret, err := handler.Receive(cctx, msg)
+		t.Logf("query response: %v", ret)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if ret == "" {
+			t.Fatalf("expected non-empty json")
+		}
+
+		// Unmarshal the JSON response
+		var respJSON []map[string]interface{}
+		if err := json.Unmarshal([]byte(ret), &respJSON); err != nil {
+			t.Fatalf("unexpected error unmarshalling JSON response: %v", err)
+		}
+
+		// Check the response fields
+		if len(respJSON) != 1 {
+			t.Fatalf("expected 1 response, got %d", len(respJSON))
+		}
+		resp := respJSON[0]
+
+		replyAny, ok := resp["reply"].(map[string]interface{})
+		if !ok {
+			t.Fatalf("expected reply field to be a map, got %v", resp["reply"])
+		}
+
+		unbond, ok := replyAny["unbond"].(map[string]interface{})
+		if !ok {
+			t.Fatalf("expected unbond field to be a map, got %v", replyAny["unbond"])
+		}
+
+		// Check the field names and values
+		if unbond["delegatorAddress"] != firstAddr {
+			t.Errorf("expected delegatorAddress %s, got %v", firstAddr, unbond["delegator_address"])
+		}
+		if unbond["validatorAddress"] != "cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj" {
+			t.Errorf("expected validatorAddress cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj, got %v", unbond["validator_address"])
+		}
+
+		entries, ok := unbond["entries"].([]interface{})
+		if !ok || len(entries) != 1 {
+			t.Fatalf("expected 1 unbonding delegation entry, got %v", entries)
+		}
+		entry, ok := entries[0].(map[string]interface{})
+		if !ok {
+			t.Fatalf("expected unbonding delegation entry to be a map, got %v", entries[0])
+		}
+		if entry["creationHeight"] != "100" {
+			t.Errorf("expected creationHeight \"100\", got %v", entry["creation_height"])
+		}
+		if entry["balance"] != "500" {
+			t.Errorf("expected balance \"500\", got %v", entry["balance"])
+		}
+		if _, ok := entry["completionTime"]; !ok {
+			t.Error("expected completionTime field in the response")
+		}
+	})
+}
+
+func TestExecuteTx(t *testing.T) {
+	alreadyAddr := sdk.MustBech32ifyAddressBytes("cosmos", []byte("already"))
+	bank := &mockBank{balances: map[string]sdk.Coins{
+		firstAddr:   []sdk.Coin{sdk.NewCoin("fresh", sdk.NewInt(123))},
+		alreadyAddr: []sdk.Coin{sdk.NewCoin("stale", sdk.NewInt(321))},
+	}}
+	transfer := &mockTransfer{}
+	staking := &mockStaking{}
+	handler, cctx := makeTestKit(bank, transfer, staking)
+
+	// create a new message
+	msg := `{"type":"VLOCALCHAIN_ALLOCATE_ADDRESS"}`
+	ret, err := handler.Receive(cctx, msg)
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if ret == "" {
+		t.Fatalf("expected non-empty json")
+	}
+	var addr string
+	if err := json.Unmarshal([]byte(ret), &addr); err != nil {
+		t.Fatalf("unexpected error unmarshalling address string: %v: %s", ret, err)
+	}
+	if addr != firstAddr {
+		t.Fatalf("expected address %v, got %v", firstAddr, addr)
+	}
+
+	testCases := []struct {
+		name          string
+		signerAddress string
+		fromAddress   string
+		toAddress     string
+		failure       string
+	}{
+		{"valid", addr, addr, alreadyAddr, ""},
+		{"parse error", `"` + addr, firstAddr, alreadyAddr, "invalid character 'c' after object key:value pair"},
+		{"invalid address", addr, alreadyAddr, alreadyAddr, "required signer cosmos1v9k8yetpv3us7src8u does not match actual signer"},
+		{"unauth", alreadyAddr, addr, alreadyAddr, "required signer cosmos1uupflqrldlpkktssnzgp3r03ff6kz4u4kzd92pjgsfddye7grrlqt9rmmt does not match actual signer"},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+
+			// create a new message
+			msg := `{"type":"VLOCALCHAIN_EXECUTE_TX","address":"` + tc.signerAddress +
+				`","messages":[{"@type":"/cosmos.bank.v1beta1.MsgSend","from_address":"` +
+				tc.fromAddress + `","to_address":"` + tc.toAddress +
+				`","amount":[{"denom":"fresh","amount":"100"}]}]}`
+
+			ret, err = handler.Receive(cctx, msg)
+			if tc.failure != "" {
+				if err == nil {
+					t.Fatalf("expected error %v, not nil with return %v", tc.failure, ret)
+				}
+				if err.Error() != tc.failure {
+					t.Fatalf("expected error %v, not %v", tc.failure, err)
+				}
+				return
+			}
+
+			if err != nil {
+				t.Fatalf("unexpected error: %s", err)
+			}
+			if ret == "" {
+				t.Fatalf("expected non-empty json")
+			}
+			if ret != "[{}]" {
+				t.Fatalf("expected response [{}], not %v", ret)
+			}
+		})
+	}
+
+	t.Run("MsgUndelegate", func(t *testing.T) {
+		// create a new message
+		msg := `{"type":"VLOCALCHAIN_EXECUTE_TX","address":"` + addr +
+			`","messages":[{"@type":"/cosmos.staking.v1beta1.MsgUndelegate","delegatorAddress":"` +
+			addr + `","validatorAddress":"cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj","amount":{"denom":"stake","amount":"100"}}]}`
+
+		ret, err := handler.Receive(cctx, msg)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if ret == "" {
+			t.Fatalf("expected non-empty json")
+		}
+
+		// Unmarshal the response
+		var resp []map[string]interface{}
+		if err := json.Unmarshal([]byte(ret), &resp); err != nil {
+			t.Fatalf("unexpected error unmarshalling response: %v", err)
+		}
+
+		// Check the response fields
+		if len(resp) != 1 {
+			t.Fatalf("expected 1 response, got %d", len(resp))
+		}
+		
+		if _, ok := resp[0]["completionTime"]; !ok {
+			t.Error("expected 'completionTime' field in response")
+		}
+	})
+}

package/x/vstorage/handler.go

@@ -3,6 +3,7 @@ package vstorage
 import (
 	"fmt"
 
+	sdkioerrors "cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
@@ -11,6 +12,6 @@ import (
 func NewHandler(k Keeper) sdk.Handler {
 	return func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) {
 		errMsg := fmt.Sprintf("Unrecognized vstorage Msg type: %T", msg)
-		return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)
+		return nil, sdkioerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)
 	}
 }

package/x/vstorage/keeper/grpc_query.go

@@ -94,7 +94,6 @@ var capDataRemotableValueFormats = map[string]string{
 //	}
 //
 // ```
-// cf. https://github.com/Agoric/agoric-sdk/blob/6e5b422b80e47c4dac151404f43faea5ab41e9b0/scripts/get-flattened-publication.sh
 func flatten(input interface{}, output map[string]interface{}, key string, top bool) error {
 	// Act on the raw representation of a Remotable.
 	if remotable, ok := input.(*capdata.CapdataRemotable); ok {

package/x/vstorage/keeper/keeper.go

@@ -10,6 +10,7 @@ import (
 	"strconv"
 	"strings"
 
+	sdkmath "cosmossdk.io/math"
 	storetypes "github.com/cosmos/cosmos-sdk/store/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	db "github.com/tendermint/tm-db"
@@ -21,8 +22,8 @@ import (
 // StreamCell is an envelope representing a sequence of values written at a path in a single block.
 // It is persisted to storage as a { "blockHeight": "<digits>", "values": ["...", ...] } JSON text
 // that off-chain consumers rely upon.
-// Many of those consumers *also* rely upon the strings of "values" being valid JSON text
-// (cf. scripts/get-flattened-publication.sh), but we do not enforce that in this package.
+// Many of those consumers *also* rely upon the strings of "values" being valid JSON text,
+// but we do not enforce that in this package.
 type StreamCell struct {
 	BlockHeight string   `json:"blockHeight"`
 	Values      []string `json:"values"`
@@ -51,14 +52,6 @@ var _ ChangeManager = (*BatchingChangeManager)(nil)
 // 2 ** 256 - 1
 var MaxSDKInt = sdk.NewIntFromBigInt(new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(256), nil), big.NewInt(1)))
 
-// TODO: Use bytes.CutPrefix once we can rely upon go >= 1.20.
-func cutPrefix(s, prefix []byte) (after []byte, found bool) {
-	if !bytes.HasPrefix(s, prefix) {
-		return s, false
-	}
-	return s[len(prefix):], true
-}
-
 // Keeper maintains the link to data storage and exposes getter/setter methods
 // for the various parts of the state machine
 type Keeper struct {
@@ -163,7 +156,7 @@ func (k Keeper) ExportStorageFromPrefix(ctx sdk.Context, pathPrefix string) []*t
 		if !strings.HasPrefix(path, pathPrefix) {
 			continue
 		}
-		value, hasPrefix := cutPrefix(rawValue, types.EncodedDataPrefix)
+		value, hasPrefix := bytes.CutPrefix(rawValue, types.EncodedDataPrefix)
 		if !hasPrefix {
 			panic(fmt.Errorf("value at path %q starts with unexpected prefix", path))
 		}
@@ -265,7 +258,7 @@ func (k Keeper) GetEntry(ctx sdk.Context, path string) agoric.KVEntry {
 	if bytes.Equal(rawValue, types.EncodedNoDataValue) {
 		return agoric.NewKVEntryWithNoValue(path)
 	}
-	value, hasPrefix := cutPrefix(rawValue, types.EncodedDataPrefix)
+	value, hasPrefix := bytes.CutPrefix(rawValue, types.EncodedDataPrefix)
 	if !hasPrefix {
 		panic(fmt.Errorf("value at path %q starts with unexpected prefix", path))
 	}
@@ -428,7 +421,7 @@ func (k Keeper) GetNoDataValue() []byte {
 	return types.EncodedNoDataValue
 }
 
-func (k Keeper) getIntValue(ctx sdk.Context, path string) (sdk.Int, error) {
+func (k Keeper) GetIntValue(ctx sdk.Context, path string) (sdkmath.Int, error) {
 	indexEntry := k.GetEntry(ctx, path)
 	if !indexEntry.HasValue() {
 		return sdk.NewInt(0), nil
@@ -441,14 +434,14 @@ func (k Keeper) getIntValue(ctx sdk.Context, path string) (sdk.Int, error) {
 	return index, nil
 }
 
-func (k Keeper) GetQueueLength(ctx sdk.Context, queuePath string) (sdk.Int, error) {
-	head, err := k.getIntValue(ctx, queuePath+".head")
+func (k Keeper) GetQueueLength(ctx sdk.Context, queuePath string) (sdkmath.Int, error) {
+	head, err := k.GetIntValue(ctx, queuePath+".head")
 	if err != nil {
-		return sdk.NewInt(0), err
+		return sdkmath.NewInt(0), err
 	}
-	tail, err := k.getIntValue(ctx, queuePath+".tail")
+	tail, err := k.GetIntValue(ctx, queuePath+".tail")
 	if err != nil {
-		return sdk.NewInt(0), err
+		return sdkmath.NewInt(0), err
 	}
 	// The tail index is exclusive
 	return tail.Sub(head), nil
@@ -457,12 +450,12 @@ func (k Keeper) GetQueueLength(ctx sdk.Context, queuePath string) (sdk.Int, erro
 func (k Keeper) PushQueueItem(ctx sdk.Context, queuePath string, value string) error {
 	// Get the current queue tail, defaulting to zero if its vstorage doesn't exist.
 	// The `tail` is the value of the next index to be inserted
-	tail, err := k.getIntValue(ctx, queuePath+".tail")
+	tail, err := k.GetIntValue(ctx, queuePath+".tail")
 	if err != nil {
 		return err
 	}
 
-	if tail.Equal(MaxSDKInt) {
+	if tail.GTE(MaxSDKInt) {
 		return errors.New(queuePath + " overflow")
 	}
 	nextTail := tail.Add(sdk.NewInt(1))