@agoric/cosmos 0.34.2-upgrade-19-dev-2a71f04.0 → 0.34.2-upgrade-20-dev-31be299.0

package/app/upgrade.go

@@ -3,9 +3,6 @@ package gaia
 import (
 	"encoding/json"
 	"fmt"
-	"reflect"
-	"strings"
-	"text/template"
 
 	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
 	swingsetkeeper "github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/keeper"
@@ -78,45 +75,30 @@ func isFirstTimeUpgradeOfThisVersion(app *GaiaApp, ctx sdk.Context) bool {
 	return true
 }
 
-func buildProposalStepWithArgs(moduleName string, entrypoint string, extra any) (vm.CoreProposalStep, error) {
-	t := template.Must(template.New("").Parse(`{
-  "module": "{{.moduleName}}",
-  "entrypoint": "{{.entrypoint}}",
-  "args": {{.args}}
-}`))
-
-	var args []byte
-	var err error
-	if extra == nil {
-		// The specified entrypoint will be called with no extra arguments after powers.
-		args = []byte(`[]`)
-	} else if reflect.TypeOf(extra).Kind() == reflect.Map && reflect.TypeOf(extra).Key().Kind() == reflect.String {
-		// The specified entrypoint will be called with this options argument after powers.
-		args, err = json.Marshal([]any{extra})
-	} else if reflect.TypeOf(extra).Kind() == reflect.Slice {
-		// The specified entrypoint will be called with each of these arguments after powers.
-		args, err = json.Marshal(extra)
-	} else {
-		return nil, fmt.Errorf("proposal extra must be nil, array, or string map, not %v", extra)
-	}
+// buildProposalStepWithArgs returns a CoreProposal representing invocation of
+// the specified module-specific entry point with arbitrary Jsonable arguments
+// provided after core-eval powers.
+func buildProposalStepWithArgs(moduleName string, entrypoint string, args ...vm.Jsonable) (vm.CoreProposalStep, error) {
+	argsBz, err := json.Marshal(args)
 	if err != nil {
 		return nil, err
 	}
 
-	var result strings.Builder
-	err = t.Execute(&result, map[string]any{
-		"moduleName": moduleName,
-		"entrypoint": entrypoint,
-		"args":       string(args),
-	})
+	mea := struct {
+		Module     string          `json:"module"`
+		Entrypoint string          `json:"entrypoint"`
+		Args       json.RawMessage `json:"args"`
+	}{
+		Module:     moduleName,
+		Entrypoint: entrypoint,
+		Args:       argsBz,
+	}
+
+	jsonBz, err := json.Marshal(mea)
 	if err != nil {
 		return nil, err
 	}
-	jsonStr := result.String()
-	jsonBz := []byte(jsonStr)
-	if !json.Valid(jsonBz) {
-		return nil, fmt.Errorf("invalid JSON: %s", jsonStr)
-	}
+
 	proposal := vm.ArbitraryCoreProposal{Json: jsonBz}
 	return vm.CoreProposalStepForModules(proposal), nil
 }
@@ -139,14 +121,6 @@ func getVariantFromUpgradeName(upgradeName string) string {
 	}
 }
 
-func upgradeMintHolderCoreProposal(targetUpgrade string) (vm.CoreProposalStep, error) {
-	return buildProposalStepFromScript(targetUpgrade, "@agoric/builders/scripts/vats/upgrade-mintHolder.js")
-}
-
-func restartFeeDistributorCoreProposal(targetUpgrade string) (vm.CoreProposalStep, error) {
-	return buildProposalStepFromScript(targetUpgrade, "@agoric/builders/scripts/inter-protocol/replace-feeDistributor-combo.js")
-}
-
 func buildProposalStepFromScript(targetUpgrade string, builderScript string) (vm.CoreProposalStep, error) {
 	variant := getVariantFromUpgradeName(targetUpgrade)
 
@@ -157,8 +131,11 @@ func buildProposalStepFromScript(targetUpgrade string, builderScript string) (vm
 	return buildProposalStepWithArgs(
 		builderScript,
 		"defaultProposalBuilder",
-		map[string]any{
-			"variant": variant,
+		// Map iteration is randomised; use an anonymous struct instead.
+		struct {
+			Variant string `json:"variant"`
+		}{
+			Variant: variant,
 		},
 	)
 }
@@ -183,6 +160,11 @@ func unreleasedUpgradeHandler(app *GaiaApp, targetUpgrade string) func(sdk.Conte
 			// Each CoreProposalStep runs sequentially, and can be constructed from
 			// one or more modules executing in parallel within the step.
 			CoreProposalSteps = append(CoreProposalSteps,
+				// Orchestration vats: Fix memory leak in vow tools
+				// vat-ibc (included in orchestration): Accommodate string sequence numbers.
+				vm.CoreProposalStepForModules(
+					"@agoric/builders/scripts/vats/upgrade-orchestration.js",
+				),
 				// Register a new ZCF to be used for all future contract instances and upgrades
 				vm.CoreProposalStepForModules(
 					"@agoric/builders/scripts/vats/upgrade-zcf.js",
@@ -192,40 +174,11 @@ func unreleasedUpgradeHandler(app *GaiaApp, targetUpgrade string) func(sdk.Conte
 				vm.CoreProposalStepForModules(
 					"@agoric/builders/scripts/smart-wallet/build-wallet-factory2-upgrade.js",
 				),
-			)
-
-			upgradeMintHolderStep, err := upgradeMintHolderCoreProposal(targetUpgrade)
-			if err != nil {
-				return nil, err
-			} else if upgradeMintHolderStep != nil {
-				CoreProposalSteps = append(CoreProposalSteps, upgradeMintHolderStep)
-			}
-			restartFeeDistributorStep, err := restartFeeDistributorCoreProposal(targetUpgrade)
-			if err != nil {
-				return nil, err
-			} else if restartFeeDistributorStep != nil {
-				CoreProposalSteps = append(CoreProposalSteps, restartFeeDistributorStep)
-			}
-
-			CoreProposalSteps = append(CoreProposalSteps,
-				vm.CoreProposalStepForModules(
-					"@agoric/builders/scripts/vats/upgrade-paRegistry.js",
-				),
-				vm.CoreProposalStepForModules(
-					"@agoric/builders/scripts/vats/upgrade-provisionPool.js",
-				),
+				// vat-bank is slowly leaking, possibly because of the liveslots resolved promise leak
+				// (https://github.com/Agoric/agoric-sdk/issues/11118). Restart to pick up the fix.
 				vm.CoreProposalStepForModules(
 					"@agoric/builders/scripts/vats/upgrade-bank.js",
 				),
-				vm.CoreProposalStepForModules(
-					"@agoric/builders/scripts/vats/upgrade-agoricNames.js",
-				),
-				vm.CoreProposalStepForModules(
-					"@agoric/builders/scripts/vats/upgrade-asset-reserve.js",
-				),
-				vm.CoreProposalStepForModules(
-					"@agoric/builders/scripts/vats/upgrade-psm.js",
-				),
 			)
 		}
 

package/app/upgrade_test.go

@@ -0,0 +1,63 @@
+package gaia
+
+import (
+	"testing"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBuildProposalSteps(t *testing.T) {
+	testCases := []struct {
+		name         string
+		makeStep     func() (vm.CoreProposalStep, error)
+		expectedJson string
+	}{
+		{
+			"buildProposalStepFromScript",
+			func() (vm.CoreProposalStep, error) {
+				return buildProposalStepFromScript(
+					"UNRELEASED_A3P_INTEGRATION",
+					"@agoric/builders/scripts/vats/upgrade-orchestration.js",
+				)
+			},
+			`{"module":"@agoric/builders/scripts/vats/upgrade-orchestration.js",` +
+				`"entrypoint":"defaultProposalBuilder",` +
+				`"args":[{"variant":"A3P_INTEGRATION"}]}`,
+		},
+		{
+			"buildProposalStepWithArgs",
+			func() (vm.CoreProposalStep, error) {
+				return buildProposalStepWithArgs(
+					"@agoric/builders/scripts/vats/upgrade-vats.js",
+					"upgradeVatsProposalBuilder",
+					// Map iteration is randomised; use an anonymous struct instead.
+					struct {
+						Ibc string `json:"ibc"`
+					}{
+						Ibc: "@agoric/vats/src/vat-ibc.js",
+					},
+				)
+			},
+			`{"module":"@agoric/builders/scripts/vats/upgrade-vats.js",` +
+				`"entrypoint":"upgradeVatsProposalBuilder",` +
+				`"args":[{"ibc":"@agoric/vats/src/vat-ibc.js"}]}`,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			ps, err := tc.makeStep()
+
+			assert.NoError(t, err)
+			expected := vm.CoreProposalStepForModules(*vm.NewArbitraryCoreProposal(
+				tc.expectedJson,
+			))
+
+			assert.EqualValues(t, len(expected), len(ps), "Expected length %d to be %d", len(expected), len(ps))
+			for i, prop := range ps {
+				assert.EqualValues(t, expected[i], prop, "Expected %d to be %v, got %v", i, expected[i], prop)
+			}
+		})
+	}
+}

package/git-revision.txt

@@ -1 +1 @@
-2a71f04
+31be299

package/go.mod

@@ -204,7 +204,7 @@ replace (
 	github.com/cosmos/iavl => github.com/cosmos/iavl v0.19.7
 
 	// Use a version of ibc-go that is compatible with the above forks.
-	github.com/cosmos/ibc-go/v6 => github.com/agoric-labs/ibc-go/v6 v6.3.1-alpha.agoric.2
+	github.com/cosmos/ibc-go/v6 => github.com/agoric-labs/ibc-go/v6 v6.3.1-alpha.agoric.4
 
 	// use cometbft
 	// Use our fork at least until post-v0.34.14 is released with

package/go.sum

@@ -235,8 +235,8 @@ github.com/agoric-labs/cosmos-sdk v0.46.16-alpha.agoric.2.5 h1:cwbONQaVbGEPzfVqv
 github.com/agoric-labs/cosmos-sdk v0.46.16-alpha.agoric.2.5/go.mod h1:Yny/YE+GJ+y/++UgvraITGzfLhXCnwETSWw3dAY5NDg=
 github.com/agoric-labs/cosmos-sdk/ics23/go v0.8.0-alpha.agoric.1 h1:2jvHI/2d+psWAZy6FQ0vXJCHUtfU3ZbbW+pQFL04arQ=
 github.com/agoric-labs/cosmos-sdk/ics23/go v0.8.0-alpha.agoric.1/go.mod h1:E45NqnlpxGnpfTWL/xauN7MRwEE28T4Dd4uraToOaKg=
-github.com/agoric-labs/ibc-go/v6 v6.3.1-alpha.agoric.2 h1:vEzy4JaExzlWNHV3ZSVXEVZcRE9loEFUjieE2TXwDdI=
-github.com/agoric-labs/ibc-go/v6 v6.3.1-alpha.agoric.2/go.mod h1:L1xcBjCLIHN7Wd9j6cAQvZertn56pq+eRGFZjRO5bsY=
+github.com/agoric-labs/ibc-go/v6 v6.3.1-alpha.agoric.4 h1:dlzsn/JzNsMWFh14lRn+pjog4L4C72SH3PNNO93xN+4=
+github.com/agoric-labs/ibc-go/v6 v6.3.1-alpha.agoric.4/go.mod h1:pNhYr/yk5M0b4tWX6Nh+SopaE/YaY0oigx1qwepLlLg=
 github.com/ajstarks/svgo v0.0.0-20180226025133-644b8db467af/go.mod h1:K08gAheRH3/J6wwsYMMT4xOr94bZjxIelGM0+d/wbFw=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/cosmos",
-  "version": "0.34.2-upgrade-19-dev-2a71f04.0+2a71f04",
+  "version": "0.34.2-upgrade-20-dev-31be299.0+31be299",
   "description": "Connect JS to the Cosmos blockchain SDK",
   "parsers": {
     "js": "mjs"
@@ -38,5 +38,5 @@
   "typeCoverage": {
     "atLeast": 0
   },
-  "gitHead": "2a71f04176f1a27be8e0356595d3dcd62f6d9186"
+  "gitHead": "31be2992aec21c06633699b7d8095423845b0530"
 }

package/types/address_hooks.go

@@ -8,8 +8,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/types/bech32"
 
 	transfertypes "github.com/cosmos/ibc-go/v6/modules/apps/transfer/types"
-	clienttypes "github.com/cosmos/ibc-go/v6/modules/core/02-client/types"
-	channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
 	ibcexported "github.com/cosmos/ibc-go/v6/modules/core/exported"
 )
 
@@ -176,7 +174,7 @@ func extractBaseTransferData(transferData transfertypes.FungibleTokenPacketData,
 // address is exactly the original address.
 // If newPacket is not nil, it is populated with a new transfer packet whose
 // corresponding Sender or Receiver is replaced with the extracted base address.
-func ExtractBaseAddressFromPacket(cdc codec.Codec, packet ibcexported.PacketI, role AddressRole, newPacket *channeltypes.Packet) (string, error) {
+func ExtractBaseAddressFromPacket(cdc codec.Codec, packet ibcexported.PacketI, role AddressRole, newPacket *IBCPacket) (string, error) {
 	var newDataP *[]byte
 	if newPacket != nil {
 		// Capture the data for the new packet.
@@ -192,13 +190,8 @@ func ExtractBaseAddressFromPacket(cdc codec.Codec, packet ibcexported.PacketI, r
 	}
 
 	// Create a new packet with the new transfer packet data.
-	*newPacket = channeltypes.NewPacket(
-		*newDataP, packet.GetSequence(),
-		packet.GetSourcePort(), packet.GetSourceChannel(),
-		packet.GetDestPort(), packet.GetDestChannel(),
-		clienttypes.MustParseHeight(packet.GetTimeoutHeight().String()),
-		packet.GetTimeoutTimestamp(),
-	)
+	*newPacket = CopyToIBCPacket(packet)
+	newPacket.Data = *newDataP
 
 	return target, nil
 }

package/types/address_hooks_test.go

@@ -12,7 +12,7 @@ import (
 	clienttypes "github.com/cosmos/ibc-go/v6/modules/core/02-client/types"
 	channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
 
-	"github.com/Agoric/agoric-sdk/golang/cosmos/types"
+	agtypes "github.com/Agoric/agoric-sdk/golang/cosmos/types"
 )
 
 func TestSplitHookedAddress(t *testing.T) {
@@ -49,7 +49,7 @@ func TestSplitHookedAddress(t *testing.T) {
 	for _, tc := range cases {
 		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
-			baseAddr, hookData, err := types.SplitHookedAddress(tc.hook)
+			baseAddr, hookData, err := agtypes.SplitHookedAddress(tc.hook)
 			if len(tc.err) > 0 {
 				require.Error(t, err)
 				require.Equal(t, tc.err, err.Error())
@@ -90,9 +90,9 @@ func TestExtractBaseAddress(t *testing.T) {
 		for _, s := range suffixes {
 			s := s
 			t.Run(b.name+" "+s.hookStr, func(t *testing.T) {
-				addrHook, err := types.JoinHookedAddress(b.addr, []byte(s.hookStr))
+				addrHook, err := agtypes.JoinHookedAddress(b.addr, []byte(s.hookStr))
 				require.NoError(t, err)
-				addr, err := types.ExtractBaseAddress(addrHook)
+				addr, err := agtypes.ExtractBaseAddress(addrHook)
 				if s.isErr {
 					require.Error(t, err)
 				} else {
@@ -101,7 +101,7 @@ func TestExtractBaseAddress(t *testing.T) {
 						require.NotEqual(t, b.addr, addr)
 					} else {
 						require.Equal(t, b.addr, addr)
-						addr, hookData, err := types.SplitHookedAddress(addrHook)
+						addr, hookData, err := agtypes.SplitHookedAddress(addrHook)
 						require.NoError(t, err)
 						require.Equal(t, b.addr, addr)
 						require.Equal(t, s.hookStr, string(hookData))
@@ -121,48 +121,48 @@ func TestExtractBaseAddressFromPacket(t *testing.T) {
 
 	cosmosAddr := "cosmos1qqxuevtt"
 	cosmosHookStr := "?foo=bar&baz=bot#fragment"
-	cosmosHook, err := types.JoinHookedAddress(cosmosAddr, []byte(cosmosHookStr))
+	cosmosHook, err := agtypes.JoinHookedAddress(cosmosAddr, []byte(cosmosHookStr))
 	require.NoError(t, err)
-	addr, hookData, err := types.SplitHookedAddress(cosmosHook)
+	addr, hookData, err := agtypes.SplitHookedAddress(cosmosHook)
 	require.NoError(t, err)
 	require.Equal(t, cosmosAddr, addr)
 	require.Equal(t, cosmosHookStr, string(hookData))
 
 	agoricAddr := "agoric1qqp0e5ys"
 	agoricHookStr := "?bingo=again"
-	agoricHook, err := types.JoinHookedAddress(agoricAddr, []byte(agoricHookStr))
+	agoricHook, err := agtypes.JoinHookedAddress(agoricAddr, []byte(agoricHookStr))
 	require.NoError(t, err)
-	addr, hookData, err = types.SplitHookedAddress(agoricHook)
+	addr, hookData, err = agtypes.SplitHookedAddress(agoricHook)
 	require.NoError(t, err)
 	require.Equal(t, agoricAddr, addr)
 	require.Equal(t, agoricHookStr, string(hookData))
 
 	cases := []struct {
 		name  string
-		addrs map[types.AddressRole]struct{ addr, baseAddr string }
+		addrs map[agtypes.AddressRole]struct{ addr, baseAddr string }
 	}{
 		{"sender has params",
-			map[types.AddressRole]struct{ addr, baseAddr string }{
-				types.RoleSender:   {cosmosHook, "cosmos1qqxuevtt"},
-				types.RoleReceiver: {"agoric1qqp0e5ys", "agoric1qqp0e5ys"},
+			map[agtypes.AddressRole]struct{ addr, baseAddr string }{
+				agtypes.RoleSender:   {cosmosHook, "cosmos1qqxuevtt"},
+				agtypes.RoleReceiver: {"agoric1qqp0e5ys", "agoric1qqp0e5ys"},
 			},
 		},
 		{"receiver has params",
-			map[types.AddressRole]struct{ addr, baseAddr string }{
-				types.RoleSender:   {"cosmos1qqxuevtt", "cosmos1qqxuevtt"},
-				types.RoleReceiver: {agoricHook, "agoric1qqp0e5ys"},
+			map[agtypes.AddressRole]struct{ addr, baseAddr string }{
+				agtypes.RoleSender:   {"cosmos1qqxuevtt", "cosmos1qqxuevtt"},
+				agtypes.RoleReceiver: {agoricHook, "agoric1qqp0e5ys"},
 			},
 		},
 		{"both are base",
-			map[types.AddressRole]struct{ addr, baseAddr string }{
-				types.RoleSender:   {"cosmos1qqxuevtt", "cosmos1qqxuevtt"},
-				types.RoleReceiver: {"agoric1qqp0e5ys", "agoric1qqp0e5ys"},
+			map[agtypes.AddressRole]struct{ addr, baseAddr string }{
+				agtypes.RoleSender:   {"cosmos1qqxuevtt", "cosmos1qqxuevtt"},
+				agtypes.RoleReceiver: {"agoric1qqp0e5ys", "agoric1qqp0e5ys"},
 			},
 		},
 		{"both have params",
-			map[types.AddressRole]struct{ addr, baseAddr string }{
-				types.RoleSender:   {agoricHook, "agoric1qqp0e5ys"},
-				types.RoleReceiver: {cosmosHook, "cosmos1qqxuevtt"},
+			map[agtypes.AddressRole]struct{ addr, baseAddr string }{
+				agtypes.RoleSender:   {agoricHook, "agoric1qqp0e5ys"},
+				agtypes.RoleReceiver: {cosmosHook, "cosmos1qqxuevtt"},
 			},
 		},
 	}
@@ -170,29 +170,29 @@ func TestExtractBaseAddressFromPacket(t *testing.T) {
 	for _, tc := range cases {
 		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
-			ftPacketData := transfertypes.NewFungibleTokenPacketData("denom", "100", tc.addrs[types.RoleSender].addr, tc.addrs[types.RoleReceiver].addr, "my-favourite-memo")
+			ftPacketData := transfertypes.NewFungibleTokenPacketData("denom", "100", tc.addrs[agtypes.RoleSender].addr, tc.addrs[agtypes.RoleReceiver].addr, "my-favourite-memo")
 			packetBz := ftPacketData.GetBytes()
-			packet := channeltypes.NewPacket(packetBz, 1234, "my-port", "my-channel", "their-port", "their-channel", clienttypes.NewHeight(133, 445), 10999)
+			packet := agtypes.MakeIBCPacket(packetBz, 1234, "my-port", "my-channel", "their-port", "their-channel", clienttypes.NewHeight(133, 445), 10999)
 
 			for role, addrs := range tc.addrs {
 				addrs := addrs
 				role := role
 
 				t.Run(string(role), func(t *testing.T) {
-					baseAddr, err := types.ExtractBaseAddress(addrs.addr)
+					baseAddr, err := agtypes.ExtractBaseAddress(addrs.addr)
 					require.NoError(t, err)
 					require.Equal(t, addrs.baseAddr, baseAddr)
 
-					packetBaseAddr0, err := types.ExtractBaseAddressFromData(cdc, packet.GetData(), role, nil)
+					packetBaseAddr0, err := agtypes.ExtractBaseAddressFromData(cdc, packet.GetData(), role, nil)
 					require.NoError(t, err)
 					require.Equal(t, addrs.baseAddr, packetBaseAddr0)
 
-					packetBaseAddr1, err := types.ExtractBaseAddressFromPacket(cdc, packet, role, nil)
+					packetBaseAddr1, err := agtypes.ExtractBaseAddressFromPacket(cdc, packet, role, nil)
 					require.NoError(t, err)
 					require.Equal(t, addrs.baseAddr, packetBaseAddr1)
 
-					var newPacket channeltypes.Packet
-					packetBaseAddr2, err := types.ExtractBaseAddressFromPacket(cdc, packet, role, &newPacket)
+					var newPacket agtypes.IBCPacket
+					packetBaseAddr2, err := agtypes.ExtractBaseAddressFromPacket(cdc, packet, role, &newPacket)
 					require.NoError(t, err)
 					require.Equal(t, addrs.baseAddr, packetBaseAddr2)
 
@@ -203,10 +203,10 @@ func TestExtractBaseAddressFromPacket(t *testing.T) {
 					// Check that the only difference between the packet data is the baseAddr.
 					packetData := basePacketData
 					switch role {
-					case types.RoleSender:
+					case agtypes.RoleSender:
 						require.Equal(t, addrs.baseAddr, basePacketData.Sender)
 						packetData.Sender = addrs.addr
-					case types.RoleReceiver:
+					case agtypes.RoleReceiver:
 						require.Equal(t, addrs.baseAddr, basePacketData.Receiver)
 						packetData.Receiver = addrs.addr
 					default:

package/types/codec.go

@@ -0,0 +1,23 @@
+package types
+
+import (
+	"github.com/cosmos/cosmos-sdk/codec"
+	cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
+)
+
+var (
+	// packageCdc is the codec used for proto3 JSON serialization of proto.Message
+	// data structures that wouldn't otherwise survive round-tripping via a
+	// regular "encoding/json" Marshal->JSON.parse.
+	//
+	// The naïve json.Marshal output for an int64 (64-bit precision) is a JSON
+	// number, which is subject to rounding errors when parsed by JavaScript
+	// (whose numbers are IEEE 754 binary64 values with only 53-bit precision).
+	// The codec.ProtoCodec uses a custom JSON marshaller that converts each int64
+	// to and from a string with no loss of precision.
+	//
+	// The current package's IBCPacket was one such affected data structure, which
+	// now implements Marshaler and Unmarshaler interfaces for "encoding/json" to
+	// take advantage of the packageCdc.
+	packageCdc = codec.NewProtoCodec(cdctypes.NewInterfaceRegistry())
+)

package/types/ibc_packet.go

@@ -0,0 +1,64 @@
+package types
+
+import (
+	"encoding/json"
+
+	clienttypes "github.com/cosmos/ibc-go/v6/modules/core/02-client/types"
+	channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
+	"github.com/cosmos/ibc-go/v6/modules/core/exported"
+)
+
+var _ json.Marshaler = IBCPacket{}
+var _ json.Unmarshaler = (*IBCPacket)(nil)
+var _ exported.PacketI = IBCPacket{}
+
+type IBCPacket struct {
+	channeltypes.Packet
+}
+
+func (p IBCPacket) MarshalJSON() ([]byte, error) {
+	return packageCdc.MarshalJSON(&p.Packet)
+}
+
+func (p *IBCPacket) UnmarshalJSON(bz []byte) error {
+	return packageCdc.UnmarshalJSON(bz, &p.Packet)
+}
+
+func MakeIBCPacket(
+	data []byte,
+	sequence uint64,
+	sourcePort string,
+	sourceChannel string,
+	destPort string,
+	destChannel string,
+	timeoutHeight clienttypes.Height,
+	timeoutTimestamp uint64,
+) IBCPacket {
+	cp := channeltypes.NewPacket(
+		data, sequence,
+		sourcePort, sourceChannel,
+		destPort, destChannel,
+		timeoutHeight, timeoutTimestamp,
+	)
+	return IBCPacket{Packet: cp}
+}
+
+func CopyToChannelPacket(packet exported.PacketI) channeltypes.Packet {
+	timeoutHeight := clienttypes.MustParseHeight(packet.GetTimeoutHeight().String())
+	return channeltypes.NewPacket(
+		packet.GetData(), packet.GetSequence(),
+		packet.GetSourcePort(), packet.GetSourceChannel(),
+		packet.GetDestPort(), packet.GetDestChannel(),
+		timeoutHeight, packet.GetTimeoutTimestamp(),
+	)
+}
+
+func CopyToIBCPacket(packet exported.PacketI) IBCPacket {
+	timeoutHeight := clienttypes.MustParseHeight(packet.GetTimeoutHeight().String())
+	return MakeIBCPacket(
+		packet.GetData(), packet.GetSequence(),
+		packet.GetSourcePort(), packet.GetSourceChannel(),
+		packet.GetDestPort(), packet.GetDestChannel(),
+		timeoutHeight, packet.GetTimeoutTimestamp(),
+	)
+}

package/types/ibc_packet_test.go

@@ -0,0 +1,117 @@
+package types_test
+
+import (
+	"bytes"
+	"encoding/json"
+	fmt "fmt"
+	"reflect"
+	"testing"
+
+	agtypes "github.com/Agoric/agoric-sdk/golang/cosmos/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	clienttypes "github.com/cosmos/ibc-go/v6/modules/core/02-client/types"
+	channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
+	ibcexported "github.com/cosmos/ibc-go/v6/modules/core/exported"
+)
+
+func CreateTestChannelPacket() channeltypes.Packet {
+	return channeltypes.NewPacket(
+		[]byte("data"),
+		987654321098765432,
+		"port-src", "channel-13",
+		"port-dst", "channel-42",
+		clienttypes.Height{},
+		123456789012345678,
+	)
+}
+
+func TestPacket(t *testing.T) {
+	testCases := []struct {
+		name   string
+		packet ibcexported.PacketI
+	}{
+		{
+			name:   "ibc-go channel Packet",
+			packet: CreateTestChannelPacket(),
+		},
+		{
+			name:   "agoric-sdk IBCPacket",
+			packet: agtypes.CopyToIBCPacket(CreateTestChannelPacket()),
+		},
+	}
+
+	// Check that the packets have the expected values
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			pi := tc.packet
+			assert.Equal(t, "port-src", pi.GetSourcePort())
+			assert.Equal(t, "channel-13", pi.GetSourceChannel())
+			assert.Equal(t, "port-dst", pi.GetDestPort())
+			assert.Equal(t, "channel-42", pi.GetDestChannel())
+			assert.Equal(t, uint64(987654321098765432), pi.GetSequence())
+			assert.Equal(t, uint64(123456789012345678), pi.GetTimeoutTimestamp())
+			assert.Equal(t, []byte("data"), pi.GetData())
+			assert.Equal(t, clienttypes.Height{}, pi.GetTimeoutHeight())
+		})
+	}
+}
+
+func TestPacketJSON(t *testing.T) {
+	testCases := []struct {
+		name   string
+		packet ibcexported.PacketI
+		quoted bool
+	}{
+		{
+			name:   "ibc-go channel Packet",
+			packet: CreateTestChannelPacket(),
+			quoted: false,
+		},
+		{
+			name:   "agoric-sdk IBCPacket",
+			packet: agtypes.CopyToIBCPacket(CreateTestChannelPacket()),
+			quoted: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			bz, err := json.Marshal(tc.packet)
+			require.NoError(t, err)
+
+			seqStr := fmt.Sprintf("%d", tc.packet.GetSequence())
+			if !bytes.Contains(bz, []byte(seqStr)) {
+				assert.Failf(t, "packet sequence should be present in JSON", "sequence %s, json %s", seqStr, string(bz))
+			}
+
+			if bytes.Contains(bz, []byte(`"`+seqStr+`"`)) != tc.quoted {
+				if tc.quoted {
+					assert.Failf(t, "packet sequence should be quoted in JSON", "sequence %s, json %s", seqStr, string(bz))
+				} else {
+					assert.Failf(t, "packet sequence should not be quoted in JSON", "sequence %s, json %s", seqStr, string(bz))
+				}
+			}
+
+			var packet2 ibcexported.PacketI
+			switch p := tc.packet.(type) {
+			case channeltypes.Packet:
+				var p2 channeltypes.Packet
+				err = json.Unmarshal(bz, &p2)
+				packet2 = p2
+			case agtypes.IBCPacket:
+				var p2 agtypes.IBCPacket
+				err = json.Unmarshal(bz, &p2)
+				packet2 = p2
+			default:
+				t.Fatalf("unexpected packet type %T", p)
+			}
+
+			require.NoError(t, err)
+			if !reflect.DeepEqual(tc.packet, packet2) {
+				assert.Failf(t, "nested packet not equal after JSON round trip", "src %q, dst %q", tc.packet, packet2)
+			}
+		})
+	}
+}