@agoric/cosmos 0.34.2-upgrade-16-fi-dev-8879538.0 → 0.34.2-upgrade-16-dev-24665a9.0

package/vm/proto_json.go

@@ -0,0 +1,38 @@
+package vm
+
+import (
+	"encoding/json"
+
+	"github.com/gogo/protobuf/jsonpb"
+	"github.com/gogo/protobuf/proto"
+)
+
+// We need jsonpb for its access to the global registry.
+var marshaller = jsonpb.Marshaler{EmitDefaults: true}
+
+func ProtoJSONMarshal(val interface{}) ([]byte, error) {
+	if pm, ok := val.(proto.Message); ok {
+		var s string
+		s, err := marshaller.MarshalToString(pm)
+		return []byte(s), err
+	}
+
+	// Marshal a non-proto value to JSON.
+	return json.Marshal(val)
+}
+
+// ProtoJSONMarshalSlice marshals a slice of proto messages and non-proto values to
+// a single JSON byte slice.
+func ProtoJSONMarshalSlice(vals []interface{}) ([]byte, error) {
+	var err error
+	jsonSlice := make([]json.RawMessage, len(vals))
+	for i, val := range vals {
+		jsonSlice[i], err = ProtoJSONMarshal(val)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// Marshal the JSON array to a single JSON byte slice.
+	return json.Marshal(jsonSlice)
+}

package/vm/proto_json_test.go

@@ -0,0 +1,103 @@
+package vm_test
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+
+	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"
+)
+
+func TestProtoJSONMarshal(t *testing.T) {
+	accAddr, err := sdk.AccAddressFromHexUnsafe("0123456789")
+	if err != nil {
+		panic(err)
+	}
+	valAddr, err := sdk.ValAddressFromHex("9876543210")
+	if err != nil {
+		panic(err)
+	}
+	coin := sdk.NewInt64Coin("uatom", 1234567)
+
+	testCases := []struct {
+		name     string
+		create   func() interface{}
+		expected string
+	}{
+		{
+			"nil",
+			func() interface{} {
+				return nil
+			},
+			`null`,
+		},
+		{
+			"primitive number",
+			func() interface{} {
+				return 12345
+			},
+			`12345`,
+		},
+		{
+			"MsgDelegate",
+			func() interface{} {
+				return stakingtypes.NewMsgDelegate(accAddr, valAddr, coin)
+			},
+			`{"delegatorAddress":"cosmos1qy352eufjjmc9c","validatorAddress":"cosmosvaloper1npm9gvss52mlmk","amount":{"denom":"uatom","amount":"1234567"}}`,
+		},
+		{
+			"QueryDenomOwnersResponse",
+			func() interface{} {
+				return &banktypes.QueryDenomOwnersResponse{
+					DenomOwners: []*banktypes.DenomOwner{
+						{
+							Address: accAddr.String(),
+							Balance: coin,
+						},
+						{
+							Address: valAddr.String(),
+							Balance: coin.Add(coin),
+						},
+					},
+				}
+			},
+			`{"denomOwners":[{"address":"cosmos1qy352eufjjmc9c","balance":{"denom":"uatom","amount":"1234567"}},{"address":"cosmosvaloper1npm9gvss52mlmk","balance":{"denom":"uatom","amount":"2469134"}}],"pagination":null}`,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			val := tc.create()
+			bz, err := vm.ProtoJSONMarshal(val)
+			if err != nil {
+				t.Errorf("ProtoJSONMarshal of %q failed %v", val, err)
+			}
+			if !bytes.Equal(bz, []byte(tc.expected)) {
+				t.Errorf("ProtoJSONMarshal of %q returned %q, expected %q", val, string(bz), tc.expected)
+			}
+		})
+	}
+
+	t.Run("all in a slice", func(t *testing.T) {
+		vals := make([]interface{}, len(testCases))
+		expectedJson := make([]string, len(testCases))
+		for i, tc := range testCases {
+			vals[i] = tc.create()
+			expectedJson[i] = tc.expected
+		}
+		bz, err := vm.ProtoJSONMarshalSlice(vals)
+		if err != nil {
+			t.Errorf("ProtoJSONMarshalSlice of %q failed %v", vals, err)
+		}
+
+		expected := "[" + strings.Join(expectedJson, ",") + "]"
+		if !bytes.Equal(bz, []byte(expected)) {
+			t.Errorf("ProtoJSONMarshalSlice of %q returned %q, expected %q", vals, string(bz), expected)
+		}
+	})
+}

package/x/swingset/alias.go

@@ -24,6 +24,8 @@ type (
 	Keeper                   = keeper.Keeper
 	SwingStoreExportsHandler = keeper.SwingStoreExportsHandler
 	ExtensionSnapshotter     = keeper.ExtensionSnapshotter
+	ActionContext            = types.ActionContext
+	InboundQueueRecord       = types.InboundQueueRecord
 	Egress                   = types.Egress
 	MsgDeliverInbound        = types.MsgDeliverInbound
 	MsgProvision             = types.MsgProvision

package/x/swingset/keeper/keeper.go

@@ -51,25 +51,6 @@ const (
 	swingStoreKeyPrefix = "swingStore."
 )
 
-// Contextual information about the message source of an action on an inbound queue.
-// This context should be unique per inboundQueueRecord.
-type actionContext struct {
-	// The block height in which the corresponding action was enqueued
-	BlockHeight int64 `json:"blockHeight"`
-	// The hash of the cosmos transaction that included the message
-	// If the action didn't result from a transaction message, a substitute value
-	// may be used. For example the VBANK_BALANCE_UPDATE actions use `x/vbank`.
-	TxHash string `json:"txHash"`
-	// The index of the message within the transaction. If the action didn't
-	// result from a cosmos transaction, a number should be chosen to make the
-	// actionContext unique. (for example a counter per block and source module).
-	MsgIdx int `json:"msgIdx"`
-}
-type inboundQueueRecord struct {
-	Action  vm.Jsonable   `json:"action"`
-	Context actionContext `json:"context"`
-}
-
 // Keeper maintains the link to data vstorage and exposes getter/setter methods for the various parts of the state machine
 type Keeper struct {
 	storeKey   storetypes.StoreKey
@@ -144,7 +125,14 @@ func (k Keeper) pushAction(ctx sdk.Context, inboundQueuePath string, action vm.A
 	if !txHashOk || !msgIdxOk {
 		stdlog.Printf("error while extracting context for action %q\n", action)
 	}
-	record := inboundQueueRecord{Action: action, Context: actionContext{BlockHeight: ctx.BlockHeight(), TxHash: txHash, MsgIdx: msgIdx}}
+	record := types.InboundQueueRecord{
+		Action: action,
+		Context: types.ActionContext{
+			BlockHeight: ctx.BlockHeight(),
+			TxHash:      txHash,
+			MsgIdx:      msgIdx,
+		},
+	}
 	bz, err := json.Marshal(record)
 	if err != nil {
 		return err

package/x/swingset/keeper/test_utils.go

@@ -0,0 +1,16 @@
+package keeper
+
+import (
+	"testing"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vstorage"
+)
+
+// GetVstorageKeeper returns the vstorage keeper from the swingset keeper
+// for testing purposes.
+func GetVstorageKeeper(t *testing.T, k Keeper) vstorage.Keeper {
+	if t == nil {
+		panic("this function is reserved for testing")
+	}
+	return k.vstorageKeeper
+}

package/x/swingset/module.go

@@ -99,6 +99,11 @@ func (AppModule) Name() string {
 	return ModuleName
 }
 
+// For testing purposes
+func (am *AppModule) SetSwingStoreExportDir(dir string) {
+	am.swingStoreExportDir = dir
+}
+
 func (am AppModule) RegisterInvariants(ir sdk.InvariantRegistry) {}
 
 func (am AppModule) Route() sdk.Route {
@@ -149,9 +154,9 @@ func (am AppModule) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) []abci.V
 	return []abci.ValidatorUpdate{}
 }
 
-func (am AppModule) checkSwingStoreExportSetup() {
+func (am *AppModule) checkSwingStoreExportSetup() {
 	if am.swingStoreExportDir == "" {
-		panic(fmt.Errorf("SwingStore export dir not set"))
+		am.swingStoreExportDir = "/tmp/swingset_export"
 	}
 }
 

package/x/swingset/testing/queue.go

@@ -0,0 +1,17 @@
+package testing
+
+import (
+	"testing"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/keeper"
+	vstoragetesting "github.com/Agoric/agoric-sdk/golang/cosmos/x/vstorage/testing"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// GetActionQueueRecords returns the records in the action queue.
+// This is a testing utility function.
+func GetActionQueueRecords(t *testing.T, ctx sdk.Context, swingsetKeeper keeper.Keeper) ([]string, error) {
+	vstorageKeeper := keeper.GetVstorageKeeper(t, swingsetKeeper)
+	actionQueueName := keeper.StoragePathActionQueue
+	return vstoragetesting.GetQueueItems(ctx, vstorageKeeper, actionQueueName)
+}

package/x/swingset/types/msgs.go

@@ -29,6 +29,25 @@ var (
 	_ vm.ControllerAdmissionMsg = &MsgWalletSpendAction{}
 )
 
+// Contextual information about the message source of an action on an inbound queue.
+// This context should be unique per inboundQueueRecord.
+type ActionContext struct {
+	// The block height in which the corresponding action was enqueued
+	BlockHeight int64 `json:"blockHeight"`
+	// The hash of the cosmos transaction that included the message
+	// If the action didn't result from a transaction message, a substitute value
+	// may be used. For example the VBANK_BALANCE_UPDATE actions use `x/vbank`.
+	TxHash string `json:"txHash"`
+	// The index of the message within the transaction. If the action didn't
+	// result from a cosmos transaction, a number should be chosen to make the
+	// actionContext unique. (for example a counter per block and source module).
+	MsgIdx int `json:"msgIdx"`
+}
+type InboundQueueRecord struct {
+	Action  vm.Jsonable   `json:"action"`
+	Context ActionContext `json:"context"`
+}
+
 const (
 	// bundleUncompressedSizeLimit is the (exclusive) limit on uncompressed bundle size.
 	// We must ensure there is an exclusive int64 limit in order to detect an underflow.

package/x/vbank/genesis.go

@@ -1,8 +1,6 @@
 package vbank
 
 import (
-	// "fmt"
-
 	"fmt"
 
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vbank/types"

package/x/vbank/types/msgs.go

@@ -1,15 +1,3 @@
 package types
 
 const RouterKey = ModuleName // this was defined in your key.go file
-
-type VbankSingleBalanceUpdate struct {
-	Address string `json:"address"`
-	Denom   string `json:"denom"`
-	Amount  string `json:"amount"`
-}
-
-type VbankBalanceUpdate struct {
-	Nonce   uint64                     `json:"nonce"`
-	Type    string                     `json:"type"`
-	Updated []VbankSingleBalanceUpdate `json:"updated"`
-}

package/x/vbank/vbank.go

@@ -34,14 +34,14 @@ func NewPortHandler(am AppModule, keeper Keeper) portHandler {
 	}
 }
 
-type vbankSingleBalanceUpdate struct {
+type VbankSingleBalanceUpdate struct {
 	Address string `json:"address"`
 	Denom   string `json:"denom"`
 	Amount  string `json:"amount"`
 }
 
 // Make vbankManyBalanceUpdates sortable
-type vbankManyBalanceUpdates []vbankSingleBalanceUpdate
+type vbankManyBalanceUpdates []VbankSingleBalanceUpdate
 
 var _ sort.Interface = vbankManyBalanceUpdates{}
 
@@ -67,7 +67,7 @@ func (vbu vbankManyBalanceUpdates) Swap(i int, j int) {
 	vbu[i], vbu[j] = vbu[j], vbu[i]
 }
 
-type vbankBalanceUpdate struct {
+type VbankBalanceUpdate struct {
 	*vm.ActionHeader `actionType:"VBANK_BALANCE_UPDATE"`
 	Nonce            uint64                  `json:"nonce"`
 	Updated          vbankManyBalanceUpdates `json:"updated"`
@@ -83,9 +83,9 @@ func getBalanceUpdate(ctx sdk.Context, keeper Keeper, addressToUpdate map[string
 	}
 
 	nonce := keeper.GetNextSequence(ctx)
-	event := vbankBalanceUpdate{
+	event := VbankBalanceUpdate{
 		Nonce:   nonce,
-		Updated: make([]vbankSingleBalanceUpdate, 0, nentries),
+		Updated: make([]VbankSingleBalanceUpdate, 0, nentries),
 	}
 
 	// Note that Golang randomises the order of iteration, so we have to sort
@@ -99,7 +99,7 @@ func getBalanceUpdate(ctx sdk.Context, keeper Keeper, addressToUpdate map[string
 		for _, coin := range coins {
 			// generate an update even when the current balance is zero
 			balance := keeper.GetBalance(ctx, account, coin.Denom)
-			update := vbankSingleBalanceUpdate{
+			update := VbankSingleBalanceUpdate{
 				Address: address,
 				Denom:   coin.Denom,
 				Amount:  balance.Amount.String(),

package/x/vbank/vbank_test.go

@@ -71,7 +71,7 @@ func newBalances(opts ...balancesOption) balances {
 	return bal
 }
 
-func validateBalanceUpdate(vbu vbankBalanceUpdate) error {
+func validateBalanceUpdate(vbu VbankBalanceUpdate) error {
 	if vbu.Type != "VBANK_BALANCE_UPDATE" {
 		return fmt.Errorf("bad balance update type: %s", vbu.Type)
 	}
@@ -89,7 +89,7 @@ func decodeBalances(encoded []byte) (balances, uint64, error) {
 	if encoded == nil {
 		return nil, 0, nil
 	}
-	balanceUpdate := vbankBalanceUpdate{}
+	balanceUpdate := VbankBalanceUpdate{}
 	err := json.Unmarshal(encoded, &balanceUpdate)
 	if err != nil {
 		return nil, 0, err

package/x/vibc/alias.go

@@ -22,6 +22,6 @@ var (
 
 type (
 	Keeper        = keeper.Keeper
-	ScopedKeeper	= types.ScopedKeeper
+	ScopedKeeper  = types.ScopedKeeper
 	MsgSendPacket = types.MsgSendPacket
 )

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_test.go

@@ -1,6 +1,15 @@
 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 +39,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)
+
+	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/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"
@@ -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)
 	}