@agoric/cosmos 0.34.2-orchestration-dev-096c4e8.0 → 0.34.2-other-dev-3eb1a1d.0

package/x/vibc/types/receiver.go

@@ -14,7 +14,7 @@ import (
 )
 
 var (
-	_ vm.PortHandler           = Receiver{}
+	_ vm.PortHandler           = (*Receiver)(nil)
 	_ exported.Acknowledgement = (*rawAcknowledgement)(nil)
 )
 
@@ -83,18 +83,28 @@ func (r rawAcknowledgement) Success() bool {
 	return true
 }
 
-func (ir Receiver) Receive(cctx context.Context, str string) (ret string, err error) {
+// Receive implements vm.PortHandler.  It unmarshals the string as JSON text
+// representing an IBC portMessage object.  If the resulting type is
+// "IBC_METHOD" it dispatches on method ("sendPacket"/"receiveExecuted"/etc.)
+// and calls the corresponding method of the wrapped ReceiverImpl.
+//
+// Otherwise, it requires the wrapped ReceiverImpl to be a vm.PortHandler
+// and delegates to the Receive method of that PortHandler.
+func (ir Receiver) Receive(cctx context.Context, jsonRequest string) (jsonReply string, err error) {
 	ctx := sdk.UnwrapSDKContext(cctx)
 	impl := ir.impl
 
 	msg := new(portMessage)
-	err = json.Unmarshal([]byte(str), &msg)
+	err = json.Unmarshal([]byte(jsonRequest), &msg)
 	if err != nil {
 		return "", err
 	}
 
 	if msg.Type != "IBC_METHOD" {
-		return "", fmt.Errorf(`channel handler only accepts messages of "type": "IBC_METHOD"`)
+		if receiver, ok := impl.(vm.PortHandler); ok {
+			return receiver.Receive(cctx, jsonRequest)
+		}
+		return "", fmt.Errorf(`channel handler only accepts messages of "type": "IBC_METHOD"; got %q`, msg.Type)
 	}
 
 	switch msg.Method {
@@ -116,7 +126,7 @@ func (ir Receiver) Receive(cctx context.Context, str string) (ret string, err er
 			packet.Sequence = seq
 			bytes, err := json.Marshal(&packet)
 			if err == nil {
-				ret = string(bytes)
+				jsonReply = string(bytes)
 			}
 		}
 
@@ -153,8 +163,8 @@ func (ir Receiver) Receive(cctx context.Context, str string) (ret string, err er
 		err = fmt.Errorf("unrecognized method %s", msg.Method)
 	}
 
-	if ret == "" && err == nil {
-		ret = "true"
+	if jsonReply == "" && err == nil {
+		jsonReply = "true"
 	}
 	return
 }

package/x/vlocalchain/handler.go

@@ -3,6 +3,7 @@ package vlocalchain
 import (
 	"fmt"
 
+	sdkioerrors "cosmossdk.io/errors"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vlocalchain/keeper"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
@@ -14,7 +15,7 @@ func NewHandler(keeper keeper.Keeper) sdk.Handler {
 		switch msg := msg.(type) {
 		default:
 			errMsg := fmt.Sprintf("Unrecognized vlocalchain Msg type: %T", msg)
-			return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)
+			return nil, sdkioerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)
 		}
 	}
 }

package/x/vlocalchain/keeper/keeper.go

@@ -28,6 +28,7 @@ type Keeper struct {
 	cdc         codec.Codec
 	msgRouter   types.MsgRouter
 	queryRouter types.GRPCQueryRouter
+	acctKeeper  types.AccountKeeper
 }
 
 // NewKeeper creates a new dIBC Keeper instance
@@ -36,12 +37,14 @@ func NewKeeper(
 	key storetypes.StoreKey,
 	msgRouter types.MsgRouter,
 	queryRouter types.GRPCQueryRouter,
+	acctKeeper types.AccountKeeper,
 ) Keeper {
 	return Keeper{
 		key:         key,
 		cdc:         cdc,
 		msgRouter:   msgRouter,
 		queryRouter: queryRouter,
+		acctKeeper:  acctKeeper,
 	}
 }
 
@@ -266,14 +269,27 @@ func (k Keeper) AllocateAddress(cctx context.Context) sdk.AccAddress {
 	localchainModuleAcc := sdkaddress.Module(types.ModuleName, []byte("localchain"))
 	header := ctx.BlockHeader()
 
-	// Increment our sequence number.
-	seq := store.Get(types.KeyLastSequence)
-	seq = types.NextSequence(seq)
-	store.Set(types.KeyLastSequence, seq)
+	// Loop until we find an unused address.
+	for {
+		// Increment our sequence number.
+		seq := store.Get(types.KeyLastSequence)
+		seq = types.NextSequence(seq)
+		store.Set(types.KeyLastSequence, seq)
 
-	buf := seq
-	buf = append(buf, header.AppHash...)
-	buf = append(buf, header.DataHash...)
+		buf := seq
+		buf = append(buf, header.AppHash...)
+		buf = append(buf, header.DataHash...)
 
-	return sdkaddress.Derive(localchainModuleAcc, buf)
+		addr := sdkaddress.Derive(localchainModuleAcc, buf)
+		if k.acctKeeper.HasAccount(ctx, addr) {
+			continue
+		}
+
+		// We found an unused address, so create an account for it.
+		acct := k.acctKeeper.NewAccountWithAddress(ctx, addr)
+		k.acctKeeper.SetAccount(ctx, acct)
+
+		// All good, return the address.
+		return addr
+	}
 }

package/x/vlocalchain/keeper/keeper_test.go

@@ -1,6 +1,14 @@
 package keeper
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/app/params"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+)
 
 func TestKeeper_ParseRequestTypeURL(t *testing.T) {
 	testCases := []struct {
@@ -30,3 +38,59 @@ func TestKeeper_ParseRequestTypeURL(t *testing.T) {
 		})
 	}
 }
+
+func TestKeeper_DeserializeTxMessages(t *testing.T) {
+	encodingConfig := params.MakeEncodingConfig()
+	cdc := encodingConfig.Marshaler
+
+	banktypes.RegisterInterfaces(encodingConfig.InterfaceRegistry)
+
+	keeper := NewKeeper(cdc, nil, nil, nil, nil)
+
+	expectedMsgSend := []sdk.Msg{
+		&banktypes.MsgSend{
+			FromAddress: "cosmos1abc",
+			ToAddress:   "cosmos1xyz",
+			Amount:      sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))),
+		},
+	}
+
+	testCases := []struct {
+		name     string
+		json     string
+		expected []sdk.Msg
+		wantErr  bool
+	}{
+		{
+			name:     "camelCase keys",
+			json:     `{"messages":[{"@type":"/cosmos.bank.v1beta1.MsgSend","fromAddress":"cosmos1abc","toAddress":"cosmos1xyz","amount":[{"denom":"stake","amount":"100"}]}]}`,
+			expected: expectedMsgSend,
+			wantErr:  false,
+		},
+		{
+			name:     "snake_case keys",
+			json:     `{"messages":[{"@type":"/cosmos.bank.v1beta1.MsgSend","from_address":"cosmos1abc","to_address":"cosmos1xyz","amount":[{"denom":"stake","amount":"100"}]}]}`,
+			expected: expectedMsgSend,
+			wantErr:  false,
+		},
+		{
+			name:     "misspelled key",
+			json:     `{"messages":[{"@type":"/cosmos.bank.v1beta1.MsgSend","from_addresss":"cosmos1abc","to_address":"cosmos1xyz","amount":[{"denom":"stake","amount":"100"}]}]}`,
+			expected: expectedMsgSend,
+			wantErr:  true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			msgs, err := keeper.DeserializeTxMessages([]byte(tc.json))
+
+			if tc.wantErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tc.expected, msgs)
+			}
+		})
+	}
+}

package/x/vlocalchain/types/expected_keepers.go

@@ -0,0 +1,12 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+)
+
+type AccountKeeper interface {
+	NewAccountWithAddress(ctx sdk.Context, addr sdk.AccAddress) authtypes.AccountI
+	HasAccount(ctx sdk.Context, addr sdk.AccAddress) bool
+	SetAccount(ctx sdk.Context, acc authtypes.AccountI)
+}

package/x/vlocalchain/vlocalchain.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/gogo/protobuf/jsonpb"
 
 	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vlocalchain/keeper"
@@ -45,7 +44,7 @@ func (h portHandler) Receive(cctx context.Context, str string) (ret string, err
 		}
 		ret = string(bz)
 
-	case "VLOCALCHAIN_QUERY":
+	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) + `}`)
@@ -56,28 +55,36 @@ func (h portHandler) Receive(cctx context.Context, str string) (ret string, err
 			return
 		}
 
-		// We need jsonpb for its access to the global registry.
-		marshaller := jsonpb.Marshaler{EmitDefaults: true, OrigName: true}
-
-		var s string
-		resps := make([]json.RawMessage, len(qms))
+		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 {
-				return
-			}
-			if s, err = marshaller.MarshalToString(qr); err != nil {
-				return
+			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()}
 			}
-			resps[i] = []byte(s)
 		}
 
-		var bz []byte
-		if bz, err = json.Marshal(resps); err != nil {
-			return
+		bz, err := vm.ProtoJSONMarshalSlice(resps)
+		if err != nil {
+			return "", err
 		}
-		ret = string(bz)
+
+		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)
@@ -97,11 +104,9 @@ func (h portHandler) Receive(cctx context.Context, str string) (ret string, err
 			return
 		}
 
-		var bz []byte
-		if bz, err = json.Marshal(resps); err != nil {
-			return
-		}
-		ret = string(bz)
+		// 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)
 	}

package/x/vlocalchain/vlocalchain_test.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/Agoric/agoric-sdk/golang/cosmos/app/params"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
@@ -15,7 +16,9 @@ import (
 	"github.com/cosmos/cosmos-sdk/store"
 	storetypes "github.com/cosmos/cosmos-sdk/store/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/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"
 
@@ -34,6 +37,25 @@ const (
 	msgAllocateAddress = `{"type":"VLOCALCHAIN_ALLOCATE_ADDRESS"}`
 )
 
+type mockAccounts struct {
+	existing map[string]bool
+}
+
+var _ types.AccountKeeper = (*mockAccounts)(nil)
+
+func (a *mockAccounts) NewAccountWithAddress(ctx sdk.Context, addr sdk.AccAddress) authtypes.AccountI {
+	return authtypes.NewBaseAccountWithAddress(addr)
+}
+
+func (a *mockAccounts) HasAccount(ctx sdk.Context, addr sdk.AccAddress) bool {
+	existing := a.existing[addr.String()]
+	return existing
+}
+
+func (a *mockAccounts) SetAccount(ctx sdk.Context, acc authtypes.AccountI) {
+	a.existing[acc.GetAddress().String()] = true
+}
+
 type mockBank struct {
 	banktypes.UnimplementedQueryServer
 	banktypes.UnimplementedMsgServer
@@ -77,8 +99,36 @@ func (t *mockTransfer) Transfer(cctx context.Context, msg *transfertypes.MsgTran
 	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) (vm.PortHandler, context.Context) {
+func makeTestKit(bank *mockBank, transfer *mockTransfer, staking *mockStaking, accts *mockAccounts) (vm.PortHandler, context.Context) {
 	encodingConfig := params.MakeEncodingConfig()
 	cdc := encodingConfig.Marshaler
 
@@ -93,9 +143,12 @@ func makeTestKit(bank *mockBank, transfer *mockTransfer) (vm.PortHandler, contex
 	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)
+	keeper := vlocalchain.NewKeeper(cdc, vlocalchainStoreKey, txRouter, queryRouter, accts)
 
 	db := dbm.NewMemDB()
 	ms := store.NewCommitMultiStore(db)
@@ -118,13 +171,16 @@ func makeTestKit(bank *mockBank, transfer *mockTransfer) (vm.PortHandler, contex
 func TestAllocateAddress(t *testing.T) {
 	bank := &mockBank{}
 	transfer := &mockTransfer{}
-	handler, cctx := makeTestKit(bank, transfer)
+	staking := &mockStaking{}
+	acct := &mockAccounts{existing: map[string]bool{
+		firstAddr: true,
+		"cosmos1c5hplwyxk5jr2dsygjqepzfqvfukwduq9c4660aah76krf99m6gs0k7hvl": true,
+	}}
+	handler, cctx := makeTestKit(bank, transfer, staking, acct)
 
 	addrs := map[string]bool{
-		firstAddr: false,
 		"cosmos1yj40fakym8kf4wvgz9tky7k9f3v9msm3t7frscrmkjsdkxkpsfkqgeczkg": false,
 		"cosmos1s76vryj7m8k8nm9le65a4plhf5rym5sumtt2n0vwnk5l6k4cwuhsj56ujj": false,
-		"cosmos1c5hplwyxk5jr2dsygjqepzfqvfukwduq9c4660aah76krf99m6gs0k7hvl": false,
 		"cosmos1ys3a7mtna3cad0wxcs4ddukn37stexjdvns8jfdn4uerlr95y4xqnrypf6": false,
 	}
 	numToTest := len(addrs)
@@ -150,6 +206,9 @@ func TestAllocateAddress(t *testing.T) {
 			t.Fatalf("unexpected duplicate address[%d]: %v", i, addr)
 		}
 		addrs[addr] = true
+		if !acct.existing[addr] {
+			t.Fatalf("expected address[%d]: %v to be added to accounts", i, addr)
+		}
 	}
 }
 
@@ -161,7 +220,9 @@ func TestQuery(t *testing.T) {
 		alreadyAddr: []sdk.Coin{sdk.NewCoin("stale", sdk.NewInt(321))},
 	}}
 	transfer := &mockTransfer{}
-	handler, cctx := makeTestKit(bank, transfer)
+	staking := &mockStaking{}
+	accts := &mockAccounts{existing: map[string]bool{}}
+	handler, cctx := makeTestKit(bank, transfer, staking, accts)
 
 	// get balances
 	testCases := []struct {
@@ -180,7 +241,7 @@ func TestQuery(t *testing.T) {
 		tc := tc
 		ctx := sdk.UnwrapSDKContext(cctx)
 		t.Run(tc.name, func(t *testing.T) {
-			msgGetBalances := `{"type":"VLOCALCHAIN_QUERY","messages":[{"@type":"/cosmos.bank.v1beta1.QueryAllBalancesRequest","address":"` + tc.addr + `"}]}`
+			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)
@@ -230,6 +291,68 @@ func TestQuery(t *testing.T) {
 			}
 		})
 	}
+
+	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) {
@@ -239,7 +362,9 @@ func TestExecuteTx(t *testing.T) {
 		alreadyAddr: []sdk.Coin{sdk.NewCoin("stale", sdk.NewInt(321))},
 	}}
 	transfer := &mockTransfer{}
-	handler, cctx := makeTestKit(bank, transfer)
+	staking := &mockStaking{}
+	accts := &mockAccounts{existing: map[string]bool{}}
+	handler, cctx := makeTestKit(bank, transfer, staking, accts)
 
 	// create a new message
 	msg := `{"type":"VLOCALCHAIN_ALLOCATE_ADDRESS"}`
@@ -302,4 +427,34 @@ func TestExecuteTx(t *testing.T) {
 			}
 		})
 	}
+
+	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/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

@@ -22,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"`
@@ -52,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 {
@@ -164,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))
 		}
@@ -266,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))
 	}
@@ -429,7 +421,7 @@ func (k Keeper) GetNoDataValue() []byte {
 	return types.EncodedNoDataValue
 }
 
-func (k Keeper) getIntValue(ctx sdk.Context, path string) (sdkmath.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
@@ -443,11 +435,11 @@ func (k Keeper) getIntValue(ctx sdk.Context, path string) (sdkmath.Int, error) {
 }
 
 func (k Keeper) GetQueueLength(ctx sdk.Context, queuePath string) (sdkmath.Int, error) {
-	head, err := k.getIntValue(ctx, queuePath+".head")
+	head, err := k.GetIntValue(ctx, queuePath+".head")
 	if err != nil {
 		return sdkmath.NewInt(0), err
 	}
-	tail, err := k.getIntValue(ctx, queuePath+".tail")
+	tail, err := k.GetIntValue(ctx, queuePath+".tail")
 	if err != nil {
 		return sdkmath.NewInt(0), err
 	}
@@ -458,12 +450,12 @@ func (k Keeper) GetQueueLength(ctx sdk.Context, queuePath string) (sdkmath.Int,
 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))

package/x/vstorage/module.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 
-	"github.com/gorilla/mux"
 	"github.com/grpc-ecosystem/grpc-gateway/runtime"
 	"github.com/spf13/cobra"
 
@@ -57,10 +56,6 @@ func (AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, config client.TxEncod
 	return ValidateGenesis(&data)
 }
 
-// Register rest routes
-func (AppModuleBasic) RegisterRESTRoutes(ctx client.Context, rtr *mux.Router) {
-}
-
 func (AppModuleBasic) RegisterGRPCGatewayRoutes(clientCtx client.Context, mux *runtime.ServeMux) {
 	_ = types.RegisterQueryHandlerClient(context.Background(), mux, types.NewQueryClient(clientCtx))
 }