@agoric/cosmos 0.35.0-u21.0 → 0.35.0-u22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/cosmos",
-  "version": "0.35.0-u21.0",
+  "version": "0.35.0-u22.0",
   "description": "Connect JS to the Cosmos blockchain SDK",
   "parsers": {
     "js": "mjs"
@@ -41,5 +41,5 @@
   "typeCoverage": {
     "atLeast": 0
   },
-  "gitHead": "e4dd46857133403d584bcf822a81817b355532f9"
+  "gitHead": "83a42d0f343b01448a918631dce159b5bdb69b7e"
 }

package/proto/agoric/swingset/msgs.proto

@@ -1,6 +1,7 @@
 syntax = "proto3";
 package agoric.swingset;
 
+import "amino/amino.proto";
 import "gogoproto/gogo.proto";
 
 option go_package = "github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/types";
@@ -22,11 +23,23 @@ service Msg {
 // MsgDeliverInbound defines an SDK message for delivering an eventual send
 message MsgDeliverInbound {
   option (gogoproto.equal) = false;
+  option (amino.name)      = "swingset/DeliverInbound";
 
-  repeated string messages  = 1 [(gogoproto.jsontag) = "messages", (gogoproto.moretags) = "yaml:\"messages\""];
-  repeated uint64 nums      = 2 [(gogoproto.jsontag) = "nums", (gogoproto.moretags) = "yaml:\"nums\""];
-  uint64          ack       = 3 [(gogoproto.jsontag) = "ack", (gogoproto.moretags) = "yaml:\"ack\""];
-  bytes           submitter = 4 [
+  repeated string messages = 1 [
+    (amino.dont_omitempty) = true,
+    (amino.encoding)       = "null_slice_as_empty",
+    (gogoproto.jsontag)    = "messages",
+    (gogoproto.moretags)   = "yaml:\"messages\""
+  ];
+  repeated uint64 nums = 2 [
+    (amino.dont_omitempty) = true,
+    (amino.encoding)       = "null_slice_as_empty",
+    (gogoproto.jsontag)    = "nums",
+    (gogoproto.moretags)   = "yaml:\"nums\""
+  ];
+  uint64 ack = 3 [(amino.dont_omitempty) = true, (gogoproto.jsontag) = "ack", (gogoproto.moretags) = "yaml:\"ack\""];
+  bytes  submitter = 4 [
+    (amino.encoding)     = "legacy_address",
     (gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress",
     (gogoproto.jsontag)  = "submitter",
     (gogoproto.moretags) = "yaml:\"submitter\""
@@ -41,8 +54,10 @@ message MsgDeliverInboundResponse {}
 // message type is typically protected by feegrant budgets.
 message MsgWalletAction {
   option (gogoproto.equal) = false;
+  option (amino.name)      = "swingset/WalletAction";
 
   bytes owner = 1 [
+    (amino.encoding)     = "legacy_address",
     (gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress",
     (gogoproto.jsontag)  = "owner",
     (gogoproto.moretags) = "yaml:\"owner\""
@@ -60,8 +75,10 @@ message MsgWalletActionResponse {}
 // typically protected by explicit confirmation by the user.
 message MsgWalletSpendAction {
   option (gogoproto.equal) = false;
+  option (amino.name)      = "swingset/WalletSpendAction";
 
   bytes owner = 1 [
+    (amino.encoding)     = "legacy_address",
     (gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress",
     (gogoproto.jsontag)  = "owner",
     (gogoproto.moretags) = "yaml:\"owner\""
@@ -77,19 +94,25 @@ message MsgWalletSpendActionResponse {}
 // MsgProvision defines an SDK message for provisioning a client to the chain
 message MsgProvision {
   option (gogoproto.equal) = false;
+  option (amino.name)      = "swingset/Provision";
 
   string nickname = 1 [(gogoproto.jsontag) = "nickname", (gogoproto.moretags) = "yaml:\"nickname\""];
   bytes  address  = 2 [
+    (amino.encoding)     = "legacy_address",
     (gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress",
     (gogoproto.jsontag)  = "address",
     (gogoproto.moretags) = "yaml:\"address\""
   ];
   repeated string power_flags = 3 [
+    (amino.dont_omitempty) = true,
+    (amino.encoding)       = "null_slice_as_empty",
+    (amino.field_name)     = "powerFlags",
     (gogoproto.customname) = "PowerFlags",
     (gogoproto.jsontag)    = "powerFlags",
     (gogoproto.moretags)   = "yaml:\"powerFlags\""
   ];
   bytes submitter = 4 [
+    (amino.encoding)     = "legacy_address",
     (gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress",
     (gogoproto.jsontag)  = "submitter",
     (gogoproto.moretags) = "yaml:\"submitter\""
@@ -101,18 +124,32 @@ message MsgProvisionResponse {}
 
 // MsgInstallBundle carries a signed bundle to SwingSet.
 message MsgInstallBundle {
-  string bundle    = 1 [(gogoproto.jsontag) = "bundle", (gogoproto.moretags) = "yaml:\"bundle\""];
-  bytes  submitter = 2 [
+  // Until agoric-upgrade-22 this message didn't have an amino name
+  // but no clients actually used amino encoding
+  option (amino.name) = "swingset/InstallBundle";
+
+  string bundle = 1
+      [(amino.dont_omitempty) = true, (gogoproto.jsontag) = "bundle", (gogoproto.moretags) = "yaml:\"bundle\""];
+  bytes submitter = 2 [
+    (amino.encoding)     = "legacy_address",
     (gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress",
     (gogoproto.jsontag)  = "submitter",
     (gogoproto.moretags) = "yaml:\"submitter\""
   ];
   // Either bundle or compressed_bundle will be set.
   // Default compression algorithm is gzip.
-  bytes compressed_bundle = 3
-      [(gogoproto.jsontag) = "compressedBundle", (gogoproto.moretags) = "yaml:\"compressedBundle\""];
+  bytes compressed_bundle = 3 [
+    (amino.dont_omitempty) = true,
+    (amino.field_name)     = "compressedBundle",
+    (gogoproto.jsontag)    = "compressedBundle",
+    (gogoproto.moretags)   = "yaml:\"compressedBundle\""
+  ];
   // Size in bytes of uncompression of compressed_bundle.
-  int64 uncompressed_size = 4 [(gogoproto.jsontag) = "uncompressedSize"];
+  int64 uncompressed_size = 4 [
+    (amino.dont_omitempty) = true,
+    (amino.field_name)     = "uncompressedSize",
+    (gogoproto.jsontag)    = "uncompressedSize"
+  ];
 }
 
 // MsgInstallBundleResponse is an empty acknowledgement that an install bundle

package/proto/agoric/swingset/swingset.proto

@@ -3,6 +3,8 @@ package agoric.swingset;
 
 import "gogoproto/gogo.proto";
 import "cosmos/base/v1beta1/coin.proto";
+import "cosmos_proto/cosmos.proto";
+import "amino/amino.proto";
 
 option go_package = "github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/types";
 
@@ -10,6 +12,9 @@ option go_package = "github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/types
 // core.
 // See `bridgeCoreEval` in agoric-sdk packages/vats/src/core/chain-behaviors.js.
 message CoreEvalProposal {
+  option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
+  option (amino.name)                        = "swingset/CoreEvalProposal";
+
   option (gogoproto.goproto_getters) = false;
 
   string title       = 1;
@@ -101,7 +106,7 @@ message StringBeans {
   string key = 1;
 
   // The actual bean value.
-  string beans = 2 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Uint", (gogoproto.nullable) = false];
+  string beans = 2 [(gogoproto.customtype) = "cosmossdk.io/math.Uint", (gogoproto.nullable) = false];
 }
 
 // Map a provisioning power flag to its corresponding fee.
@@ -131,7 +136,7 @@ message QueueSize {
 message UintMapEntry {
   option (gogoproto.equal) = true;
   string key               = 1;
-  string value = 2 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Uint", (gogoproto.nullable) = false];
+  string value             = 2 [(gogoproto.customtype) = "cosmossdk.io/math.Uint", (gogoproto.nullable) = false];
 }
 
 // Egress is the format for a swingset egress.

package/proto/agoric/vbank/vbank.proto

@@ -21,7 +21,7 @@ message Params {
   // per-block distribution.
   string per_epoch_reward_fraction = 2 [
     (gogoproto.moretags)   = "yaml:\"discrete_epoch_reward_fraction\"",
-    (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec",
+    (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
     (gogoproto.nullable)   = false
   ];
 

package/proto/agoric/vibc/msgs.proto

@@ -1,6 +1,7 @@
 syntax = "proto3";
 package agoric.vibc;
 
+import "amino/amino.proto";
 import "gogoproto/gogo.proto";
 import "ibc/core/channel/v1/channel.proto";
 
@@ -15,10 +16,13 @@ service Msg {
 // MsgSendPacket is an SDK message for sending an outgoing IBC packet
 message MsgSendPacket {
   option (gogoproto.equal) = false;
+  option (amino.name)      = "vibc/SendPacket";
 
   ibc.core.channel.v1.Packet packet = 1
       [(gogoproto.nullable) = false, (gogoproto.jsontag) = "packet", (gogoproto.moretags) = "yaml:\"packet\""];
   bytes sender = 2 [
+    (amino.encoding)     = "legacy_address",
+    (amino.field_name)   = "submitter",
     (gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress",
     (gogoproto.jsontag)  = "submitter",
     (gogoproto.moretags) = "yaml:\"submitter\""

package/tests/e2e/vbank/vbank_test.go

@@ -0,0 +1,172 @@
+package vbank_test
+
+import (
+	"cosmossdk.io/math"
+	"github.com/stretchr/testify/suite"
+
+	"github.com/cometbft/cometbft/crypto/secp256k1"
+	"github.com/cosmos/cosmos-sdk/testutil/network"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+)
+
+// Generate test accounts using secp256k1 keys
+var (
+	priv1 = secp256k1.GenPrivKey()
+	priv2 = secp256k1.GenPrivKey()
+	addr1 = sdk.AccAddress(priv1.PubKey().Address()).String()
+	addr2 = sdk.AccAddress(priv2.PubKey().Address()).String()
+)
+
+type E2ETestSuite struct {
+	suite.Suite
+	cfg     network.Config
+	network *network.Network
+}
+
+func NewE2ETestSuite(cfg network.Config) *E2ETestSuite {
+	return &E2ETestSuite{cfg: cfg}
+}
+
+func (s *E2ETestSuite) SetupSuite() {
+	s.T().Log("setting up e2e test suite")
+
+	genesisState := s.cfg.GenesisState
+	bankGenesis := banktypes.DefaultGenesisState()
+
+	bankGenesis.DenomMetadata = []banktypes.Metadata{
+		{
+			Name:        "Agoric",
+			Symbol:      "BLD",
+			Description: "AgorickToken",
+			DenomUnits: []*banktypes.DenomUnit{
+				{
+					Denom:    "ulbd",
+					Exponent: 0,
+					Aliases:  []string{"microlbd"},
+				},
+				{
+					Denom:    "lbd",
+					Exponent: 6,
+					Aliases:  []string{"LBD"},
+				},
+			},
+			Base:    "ulbd",
+			Display: "lbd",
+		},
+	}
+
+	// Add two accounts with 10000 lbd each (10000 * 10^6 ulbd = 10000000000 ulbd)
+	// Using generated addresses from testutil
+	bankGenesis.Balances = []banktypes.Balance{
+		{
+			Address: addr1,
+			Coins: sdk.NewCoins(
+				sdk.NewCoin("ulbd", math.NewInt(10000000000)), // 10000 lbd
+			),
+		},
+		{
+			Address: addr2,
+			Coins: sdk.NewCoins(
+				sdk.NewCoin("ulbd", math.NewInt(10000000000)), // 10000 lbd
+			),
+		},
+	}
+
+	genesisState[banktypes.ModuleName] = s.cfg.Codec.MustMarshalJSON(bankGenesis)
+	s.cfg.GenesisState = genesisState
+
+	var err error
+	s.network, err = network.New(s.T(), s.T().TempDir(), s.cfg)
+	s.Require().NoError(err)
+
+	_, err = s.network.WaitForHeight(1)
+	s.Require().NoError(err)
+}
+
+func (s *E2ETestSuite) TearDownSuite() {
+	s.T().Log("tearing down e2e test suite")
+	s.network.Cleanup()
+}
+
+func (s *E2ETestSuite) TestSendTokens() {
+	s.T().Log("testing token transfer")
+
+	val := s.network.Validators[0]
+	ctx := val.ClientCtx
+
+	// Generate a new recipient account
+	recipientPriv := secp256k1.GenPrivKey()
+	recipientAddr := sdk.AccAddress(recipientPriv.PubKey().Address())
+
+	// Get the app instance for direct keeper access
+	app := val.ClientCtx.InterfaceRegistry
+	s.Require().NotNil(app)
+
+	// Create a send message for 1000 lbd (1000000000 ulbd)
+	sendAmount := sdk.NewCoins(sdk.NewCoin("ulbd", math.NewInt(1000000000))) // 1000 lbd
+
+	msgSend := &banktypes.MsgSend{
+		FromAddress: addr1,
+		ToAddress:   recipientAddr.String(),
+		Amount:      sendAmount,
+	}
+
+	s.T().Logf("Sending %s from %s to %s", sendAmount, addr1, recipientAddr.String())
+
+	// Create and broadcast the transaction
+	txBuilder := ctx.TxConfig.NewTxBuilder()
+	err := txBuilder.SetMsgs(msgSend)
+	s.Require().NoError(err)
+
+	// Set gas and fees
+	txBuilder.SetGasLimit(200000)
+	fees := sdk.NewCoins(sdk.NewCoin("ulbd", math.NewInt(100000))) // Fee in ulbd
+	txBuilder.SetFeeAmount(fees)
+
+	// For this test, we'll broadcast using the validator's address as a proxy
+	// In a real scenario, we'd sign with the actual sender's private key
+	txBuilder.SetFeeGranter(val.Address)
+
+	// Build and encode the transaction
+	txBytes, err := ctx.TxConfig.TxEncoder()(txBuilder.GetTx())
+	s.Require().NoError(err)
+	s.Require().NotNil(txBytes)
+
+	s.T().Logf("Transaction created successfully with size: %d bytes", len(txBytes))
+
+	// Broadcast the transaction
+	res, err := ctx.BroadcastTx(txBytes)
+	s.Require().NoError(err)
+	s.T().Logf("Transaction broadcast result: %+v", res)
+
+	// Wait for the transaction to be processed
+	s.Require().NoError(s.network.WaitForNextBlock())
+
+	// Query the recipient's balance to verify they received the tokens
+	queryClient := banktypes.NewQueryClient(ctx)
+	balanceReq := &banktypes.QueryAllBalancesRequest{
+		Address: recipientAddr.String(),
+	}
+
+	balanceResp, err := queryClient.AllBalances(val.ClientCtx.CmdContext, balanceReq)
+	s.Require().NoError(err)
+
+	// Verify the recipient received exactly 1000 lbd (1000000000 ulbd)
+	expectedAmount := math.NewInt(1000000000)
+	found := false
+	actualBalance := math.ZeroInt()
+
+	for _, coin := range balanceResp.Balances {
+		if coin.Denom == "ulbd" {
+			actualBalance = coin.Amount
+			if coin.Amount.Equal(expectedAmount) {
+				found = true
+			}
+			break
+		}
+	}
+
+	s.Require().True(found, "Recipient should have received exactly 1000 lbd (1000000000 ulbd), but got %s ulbd", actualBalance.String())
+
+}

package/tests/integrations/types/aminojson_test.go

@@ -0,0 +1,214 @@
+package types_test
+
+import (
+	"context"
+	"encoding/json"
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-proto/anyutil"
+	gogoproto "github.com/cosmos/gogoproto/proto"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/types/known/anypb"
+
+	v1beta1 "cosmossdk.io/api/cosmos/base/v1beta1"
+	txv1beta1 "cosmossdk.io/api/cosmos/tx/v1beta1"
+	signing_testutil "cosmossdk.io/x/tx/signing/testutil"
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/module/testutil"
+	signingtypes "github.com/cosmos/cosmos-sdk/types/tx/signing"
+	"github.com/cosmos/cosmos-sdk/x/auth"
+	"github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx"
+	"github.com/cosmos/cosmos-sdk/x/auth/signing"
+	"github.com/cosmos/cosmos-sdk/x/auth/tx"
+	"github.com/cosmos/cosmos-sdk/x/auth/vesting"
+	authzmodule "github.com/cosmos/cosmos-sdk/x/authz/module"
+	"github.com/cosmos/cosmos-sdk/x/bank"
+	"github.com/cosmos/cosmos-sdk/x/gov"
+	govv1beta1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1"
+	"github.com/cosmos/cosmos-sdk/x/params"
+	"github.com/cosmos/cosmos-sdk/x/params/types/proposal"
+	"github.com/cosmos/cosmos-sdk/x/slashing"
+	"github.com/cosmos/cosmos-sdk/x/staking"
+	clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types"
+	channeltypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/app/txconfig"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset"
+	swingsettypes "github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/types"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vbank"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vibc"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vstorage"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vtransfer"
+)
+
+func TestAminoJSON_LegacyParity(t *testing.T) {
+	encCfg := testutil.MakeTestEncodingConfig(
+		auth.AppModuleBasic{},
+		vesting.AppModuleBasic{},
+		bank.AppModuleBasic{},
+		gov.AppModuleBasic{},
+		slashing.AppModuleBasic{},
+		staking.AppModuleBasic{},
+		authzmodule.AppModuleBasic{},
+		params.AppModuleBasic{},
+		vstorage.AppModuleBasic{},
+		swingset.AppModuleBasic{},
+		vibc.AppModuleBasic{},
+		vbank.AppModuleBasic{},
+		vtransfer.AppModuleBasic{},
+	)
+	legacytx.RegressionTestingAminoCodec = encCfg.Amino
+
+	signingOpts, err := tx.NewDefaultSigningOptions()
+	require.NoError(t, err)
+
+	handler, aj, err := txconfig.NewAminoHandlerWithCustomEncoders(signingOpts, txconfig.CustomAminoFieldEncoders)
+	require.NoError(t, err)
+
+	addr1 := sdk.AccAddress("addr1")
+	deliverMessages := &swingsettypes.Messages{Messages: []string{"{}"}, Nums: []uint64{2}, Ack: 1}
+	emptyDeliverMessages := &swingsettypes.Messages{Messages: []string{}, Nums: []uint64{}, Ack: 1}
+	zeroDeliverMessages := &swingsettypes.Messages{Messages: []string{"{}"}, Nums: []uint64{2}, Ack: 0}
+	coins := sdk.Coins{sdk.NewInt64Coin("uatom", 1000)}
+
+	installBundleMsg := swingsettypes.NewMsgInstallBundle("{}", addr1)
+	err = installBundleMsg.ValidateBasic()
+	require.NoError(t, err)
+
+	compressedInstallBundleMsg := new(swingsettypes.MsgInstallBundle)
+	*compressedInstallBundleMsg = *installBundleMsg
+	err = compressedInstallBundleMsg.Compress()
+	require.NoError(t, err)
+
+	coreEvalProposal := swingsettypes.NewCoreEvalProposal("test core eval", "Some core eval", []swingsettypes.CoreEval{{JsonPermits: "true", JsCode: ";"}})
+	err = coreEvalProposal.ValidateBasic()
+	require.NoError(t, err)
+
+	coreEvalGovMsg, err := govv1beta1.NewMsgSubmitProposal(coreEvalProposal, coins, addr1)
+	require.NoError(t, err)
+
+	paramsChangeProposal := proposal.NewParameterChangeProposal("title", "description", []proposal.ParamChange{proposal.NewParamChange("swingset", "foo", "bar")})
+	err = paramsChangeProposal.ValidateBasic()
+	require.NoError(t, err)
+
+	paramsChangeGovMsg, err := govv1beta1.NewMsgSubmitProposal(paramsChangeProposal, coins, addr1)
+	require.NoError(t, err)
+
+	ibcPacket := channeltypes.NewPacket(
+		[]byte("data"),
+		987654321098765432,
+		"port-src", "channel-13",
+		"port-dst", "channel-42",
+		clienttypes.Height{},
+		123456789012345678,
+	)
+
+	cases := map[string]struct {
+		gogo gogoproto.Message
+		// If there are any empty slices, the marshal round trip to bytes will likely transform these into nil slices
+		roundTripUnequal bool
+	}{
+		"swingset/msg_deliver_inbound/normal":    {gogo: swingsettypes.NewMsgDeliverInbound(deliverMessages, addr1)},
+		"swingset/msg_deliver_inbound/empty":     {gogo: swingsettypes.NewMsgDeliverInbound(emptyDeliverMessages, addr1), roundTripUnequal: true},
+		"swingset/msg_deliver_inbound/zero":      {gogo: swingsettypes.NewMsgDeliverInbound(zeroDeliverMessages, addr1)},
+		"swingset/msg_wallet_action":             {gogo: swingsettypes.NewMsgWalletAction(addr1, "{}")},
+		"swingset/msg_wallet_spend_action":       {gogo: swingsettypes.NewMsgWalletSpendAction(addr1, "{}")},
+		"swingset/msg_provision/normal":          {gogo: swingsettypes.NewMsgProvision("foo", addr1, []string{"bar"}, addr1)},
+		"swingset/msg_provision/empty":           {gogo: swingsettypes.NewMsgProvision("foo", addr1, []string{}, addr1), roundTripUnequal: true},
+		"swingset/msg_install_bundle":            {gogo: installBundleMsg},
+		"swingset/msg_install_bundle/compressed": {gogo: compressedInstallBundleMsg},
+		"swingset/gov/core_eval_proposal":        {gogo: coreEvalGovMsg},
+		"swingset/gov/params_change_proposal":    {gogo: paramsChangeGovMsg},
+		"vibc/msg_send_packet":                   {gogo: vibc.NewMsgSendPacket(ibcPacket, addr1)},
+	}
+
+	for name, tc := range cases {
+		t.Run(name, func(t *testing.T) {
+			gogoMsg := tc.gogo
+
+			// Convert gogoproto into new proto msg like tx would
+			anyGogoMsg, err := codectypes.NewAnyWithValue(gogoMsg)
+			require.NoError(t, err)
+
+			protoMsg, err := anyutil.Unpack(&anypb.Any{
+				TypeUrl: anyGogoMsg.TypeUrl,
+				Value:   anyGogoMsg.Value,
+			}, encCfg.InterfaceRegistry, nil)
+			require.NoError(t, err)
+
+			protoBz, err := proto.Marshal(protoMsg)
+			require.NoError(t, err)
+
+			// Sanity check
+			gogoType := reflect.TypeOf(gogoMsg).Elem()
+			newGogo := reflect.New(gogoType).Interface().(gogoproto.Message)
+			err = encCfg.Codec.Unmarshal(protoBz, newGogo)
+			require.NoError(t, err)
+			if tc.roundTripUnequal {
+				require.NotEqual(t, gogoMsg, newGogo)
+			} else {
+				require.Equal(t, gogoMsg, newGogo)
+			}
+
+			// Check amino json encoding matches
+			anyProtoMsg, err := anyutil.New(protoMsg)
+			require.NoError(t, err)
+
+			legacyAminoJSON, err := encCfg.Amino.MarshalJSON(gogoMsg)
+			require.NoError(t, err)
+			legacyAminoJSON = sortJSON(t, legacyAminoJSON)
+			aminoJSON, err := aj.Marshal(anyProtoMsg)
+			require.NoError(t, err)
+			require.Equal(t, string(legacyAminoJSON), string(aminoJSON))
+
+			handlerOptions := signing_testutil.HandlerArgumentOptions{
+				ChainID:       "test-chain",
+				Memo:          "sometestmemo",
+				Msg:           protoMsg,
+				AccNum:        1,
+				AccSeq:        2,
+				SignerAddress: "signerAddress",
+				Fee: &txv1beta1.Fee{
+					Amount: []*v1beta1.Coin{{Denom: "uatom", Amount: "1000"}},
+				},
+			}
+
+			signerData, txData, err := signing_testutil.MakeHandlerArguments(handlerOptions)
+			require.NoError(t, err)
+
+			signBz, err := handler.GetSignBytes(context.Background(), signerData, txData)
+			require.NoError(t, err)
+
+			legacyHandler := tx.NewSignModeLegacyAminoJSONHandler()
+			txBuilder := encCfg.TxConfig.NewTxBuilder()
+			require.NoError(t, txBuilder.SetMsgs([]sdk.Msg{gogoMsg}...))
+			txBuilder.SetMemo(handlerOptions.Memo)
+			txBuilder.SetFeeAmount(sdk.Coins{sdk.NewInt64Coin("uatom", 1000)})
+			theTx := txBuilder.GetTx()
+
+			legacySigningData := signing.SignerData{
+				ChainID:       handlerOptions.ChainID,
+				Address:       handlerOptions.SignerAddress,
+				AccountNumber: handlerOptions.AccNum,
+				Sequence:      handlerOptions.AccSeq,
+			}
+			legacySignBz, err := legacyHandler.GetSignBytes(signingtypes.SignMode_SIGN_MODE_LEGACY_AMINO_JSON,
+				legacySigningData, theTx)
+			require.NoError(t, err)
+			require.Equal(t, string(legacySignBz), string(signBz))
+		})
+	}
+}
+
+func sortJSON(t require.TestingT, bz []byte) []byte {
+	var c interface{}
+	err := json.Unmarshal(bz, &c)
+	require.NoError(t, err)
+	bz, err = json.Marshal(c)
+	require.NoError(t, err)
+	return bz
+}