@agoric/cosmos 0.35.0-u19.2 → 0.35.0-u21.0

package/third_party/proto/cosmos/ics23/v1/proofs.proto

@@ -0,0 +1,243 @@
+syntax = "proto3";
+
+package cosmos.ics23.v1;
+
+option go_package = "github.com/cosmos/ics23/go;ics23";
+
+enum HashOp {
+  // NO_HASH is the default if no data passed. Note this is an illegal argument some places.
+  NO_HASH     = 0;
+  SHA256      = 1;
+  SHA512      = 2;
+  KECCAK256   = 3;
+  RIPEMD160   = 4;
+  BITCOIN     = 5; // ripemd160(sha256(x))
+  SHA512_256  = 6;
+  BLAKE2B_512 = 7;
+  BLAKE2S_256 = 8;
+  BLAKE3      = 9;
+}
+
+/**
+LengthOp defines how to process the key and value of the LeafOp
+to include length information. After encoding the length with the given
+algorithm, the length will be prepended to the key and value bytes.
+(Each one with it's own encoded length)
+*/
+enum LengthOp {
+  // NO_PREFIX don't include any length info
+  NO_PREFIX = 0;
+  // VAR_PROTO uses protobuf (and go-amino) varint encoding of the length
+  VAR_PROTO = 1;
+  // VAR_RLP uses rlp int encoding of the length
+  VAR_RLP = 2;
+  // FIXED32_BIG uses big-endian encoding of the length as a 32 bit integer
+  FIXED32_BIG = 3;
+  // FIXED32_LITTLE uses little-endian encoding of the length as a 32 bit integer
+  FIXED32_LITTLE = 4;
+  // FIXED64_BIG uses big-endian encoding of the length as a 64 bit integer
+  FIXED64_BIG = 5;
+  // FIXED64_LITTLE uses little-endian encoding of the length as a 64 bit integer
+  FIXED64_LITTLE = 6;
+  // REQUIRE_32_BYTES is like NONE, but will fail if the input is not exactly 32 bytes (sha256 output)
+  REQUIRE_32_BYTES = 7;
+  // REQUIRE_64_BYTES is like NONE, but will fail if the input is not exactly 64 bytes (sha512 output)
+  REQUIRE_64_BYTES = 8;
+}
+
+/**
+ExistenceProof takes a key and a value and a set of steps to perform on it.
+The result of peforming all these steps will provide a "root hash", which can
+be compared to the value in a header.
+
+Since it is computationally infeasible to produce a hash collission for any of the used
+cryptographic hash functions, if someone can provide a series of operations to transform
+a given key and value into a root hash that matches some trusted root, these key and values
+must be in the referenced merkle tree.
+
+The only possible issue is maliablity in LeafOp, such as providing extra prefix data,
+which should be controlled by a spec. Eg. with lengthOp as NONE,
+  prefix = FOO, key = BAR, value = CHOICE
+and
+  prefix = F, key = OOBAR, value = CHOICE
+would produce the same value.
+
+With LengthOp this is tricker but not impossible. Which is why the "leafPrefixEqual" field
+in the ProofSpec is valuable to prevent this mutability. And why all trees should
+length-prefix the data before hashing it.
+*/
+message ExistenceProof {
+  bytes            key   = 1;
+  bytes            value = 2;
+  LeafOp           leaf  = 3;
+  repeated InnerOp path  = 4;
+}
+
+/*
+NonExistenceProof takes a proof of two neighbors, one left of the desired key,
+one right of the desired key. If both proofs are valid AND they are neighbors,
+then there is no valid proof for the given key.
+*/
+message NonExistenceProof {
+  bytes          key   = 1; // TODO: remove this as unnecessary??? we prove a range
+  ExistenceProof left  = 2;
+  ExistenceProof right = 3;
+}
+
+/*
+CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages
+*/
+message CommitmentProof {
+  oneof proof {
+    ExistenceProof       exist      = 1;
+    NonExistenceProof    nonexist   = 2;
+    BatchProof           batch      = 3;
+    CompressedBatchProof compressed = 4;
+  }
+}
+
+/**
+LeafOp represents the raw key-value data we wish to prove, and
+must be flexible to represent the internal transformation from
+the original key-value pairs into the basis hash, for many existing
+merkle trees.
+
+key and value are passed in. So that the signature of this operation is:
+  leafOp(key, value) -> output
+
+To process this, first prehash the keys and values if needed (ANY means no hash in this case):
+  hkey = prehashKey(key)
+  hvalue = prehashValue(value)
+
+Then combine the bytes, and hash it
+  output = hash(prefix || length(hkey) || hkey || length(hvalue) || hvalue)
+*/
+message LeafOp {
+  HashOp   hash          = 1;
+  HashOp   prehash_key   = 2;
+  HashOp   prehash_value = 3;
+  LengthOp length        = 4;
+  // prefix is a fixed bytes that may optionally be included at the beginning to differentiate
+  // a leaf node from an inner node.
+  bytes prefix = 5;
+}
+
+/**
+InnerOp represents a merkle-proof step that is not a leaf.
+It represents concatenating two children and hashing them to provide the next result.
+
+The result of the previous step is passed in, so the signature of this op is:
+  innerOp(child) -> output
+
+The result of applying InnerOp should be:
+  output = op.hash(op.prefix || child || op.suffix)
+
+  where the || operator is concatenation of binary data,
+and child is the result of hashing all the tree below this step.
+
+Any special data, like prepending child with the length, or prepending the entire operation with
+some value to differentiate from leaf nodes, should be included in prefix and suffix.
+If either of prefix or suffix is empty, we just treat it as an empty string
+*/
+message InnerOp {
+  HashOp hash   = 1;
+  bytes  prefix = 2;
+  bytes  suffix = 3;
+}
+
+/**
+ProofSpec defines what the expected parameters are for a given proof type.
+This can be stored in the client and used to validate any incoming proofs.
+
+  verify(ProofSpec, Proof) -> Proof | Error
+
+As demonstrated in tests, if we don't fix the algorithm used to calculate the
+LeafHash for a given tree, there are many possible key-value pairs that can
+generate a given hash (by interpretting the preimage differently).
+We need this for proper security, requires client knows a priori what
+tree format server uses. But not in code, rather a configuration object.
+*/
+message ProofSpec {
+  // any field in the ExistenceProof must be the same as in this spec.
+  // except Prefix, which is just the first bytes of prefix (spec can be longer)
+  LeafOp    leaf_spec  = 1;
+  InnerSpec inner_spec = 2;
+  // max_depth (if > 0) is the maximum number of InnerOps allowed (mainly for fixed-depth tries)
+  // the max_depth is interpreted as 128 if set to 0
+  int32 max_depth = 3;
+  // min_depth (if > 0) is the minimum number of InnerOps allowed (mainly for fixed-depth tries)
+  int32 min_depth = 4;
+  // prehash_key_before_comparison is a flag that indicates whether to use the
+  // prehash_key specified by LeafOp to compare lexical ordering of keys for
+  // non-existence proofs.
+  bool prehash_key_before_comparison = 5;
+}
+
+/*
+InnerSpec contains all store-specific structure info to determine if two proofs from a
+given store are neighbors.
+
+This enables:
+
+  isLeftMost(spec: InnerSpec, op: InnerOp)
+  isRightMost(spec: InnerSpec, op: InnerOp)
+  isLeftNeighbor(spec: InnerSpec, left: InnerOp, right: InnerOp)
+*/
+message InnerSpec {
+  // Child order is the ordering of the children node, must count from 0
+  // iavl tree is [0, 1] (left then right)
+  // merk is [0, 2, 1] (left, right, here)
+  repeated int32 child_order       = 1;
+  int32          child_size        = 2;
+  int32          min_prefix_length = 3;
+  // the max prefix length must be less than the minimum prefix length + child size
+  int32 max_prefix_length = 4;
+  // empty child is the prehash image that is used when one child is nil (eg. 20 bytes of 0)
+  bytes empty_child = 5;
+  // hash is the algorithm that must be used for each InnerOp
+  HashOp hash = 6;
+}
+
+/*
+BatchProof is a group of multiple proof types than can be compressed
+*/
+message BatchProof {
+  repeated BatchEntry entries = 1;
+}
+
+// Use BatchEntry not CommitmentProof, to avoid recursion
+message BatchEntry {
+  oneof proof {
+    ExistenceProof    exist    = 1;
+    NonExistenceProof nonexist = 2;
+  }
+}
+
+/****** all items here are compressed forms *******/
+
+message CompressedBatchProof {
+  repeated CompressedBatchEntry entries       = 1;
+  repeated InnerOp              lookup_inners = 2;
+}
+
+// Use BatchEntry not CommitmentProof, to avoid recursion
+message CompressedBatchEntry {
+  oneof proof {
+    CompressedExistenceProof    exist    = 1;
+    CompressedNonExistenceProof nonexist = 2;
+  }
+}
+
+message CompressedExistenceProof {
+  bytes  key   = 1;
+  bytes  value = 2;
+  LeafOp leaf  = 3;
+  // these are indexes into the lookup_inners table in CompressedBatchProof
+  repeated int32 path = 4;
+}
+
+message CompressedNonExistenceProof {
+  bytes                    key   = 1; // TODO: remove this as unnecessary??? we prove a range
+  CompressedExistenceProof left  = 2;
+  CompressedExistenceProof right = 3;
+}

package/third_party/proto/cosmos/msg/v1/msg.proto

@@ -0,0 +1,30 @@
+syntax = "proto3";
+
+package cosmos.msg.v1;
+
+import "google/protobuf/descriptor.proto";
+
+// TODO(fdymylja): once we fully migrate to protov2 the go_package needs to be updated.
+// We need this right now because gogoproto codegen needs to import the extension.
+option go_package = "github.com/cosmos/cosmos-sdk/types/msgservice";
+
+extend google.protobuf.ServiceOptions {
+  // service indicates that the service is a Msg service and that requests
+  // must be transported via blockchain transactions rather than gRPC.
+  // Tooling can use this annotation to distinguish between Msg services and
+  // other types of services via reflection.
+  bool service = 11110000;
+}
+
+extend google.protobuf.MessageOptions {
+  // signer must be used in cosmos messages in order
+  // to signal to external clients which fields in a
+  // given cosmos message must be filled with signer
+  // information (address).
+  // The field must be the protobuf name of the message
+  // field extended with this MessageOption.
+  // The field must either be of string kind, or of message
+  // kind in case the signer information is contained within
+  // a message inside the cosmos message.
+  repeated string signer = 11110000;
+}

package/third_party/proto/cosmos/upgrade/v1beta1/upgrade.proto

@@ -5,12 +5,14 @@ import "google/protobuf/any.proto";
 import "gogoproto/gogo.proto";
 import "google/protobuf/timestamp.proto";
 import "cosmos_proto/cosmos.proto";
+import "amino/amino.proto";
 
 option go_package                      = "github.com/cosmos/cosmos-sdk/x/upgrade/types";
 option (gogoproto.goproto_getters_all) = false;
 
 // Plan specifies information about a planned upgrade and when it should occur.
 message Plan {
+  option (amino.name)                 = "cosmos-sdk/Plan";
   option (gogoproto.equal)            = true;
   option (gogoproto.goproto_stringer) = false;
 
@@ -26,10 +28,10 @@ message Plan {
   // Deprecated: Time based upgrades have been deprecated. Time based upgrade logic
   // has been removed from the SDK.
   // If this field is not empty, an error will be thrown.
-  google.protobuf.Timestamp time = 2 [deprecated = true, (gogoproto.stdtime) = true, (gogoproto.nullable) = false];
+  google.protobuf.Timestamp time = 2
+      [deprecated = true, (gogoproto.stdtime) = true, (gogoproto.nullable) = false, (amino.dont_omitempty) = true];
 
   // The height at which the upgrade must be performed.
-  // Only used if Time is not set.
   int64 height = 3;
 
   // Any application specific upgrade info to be included on-chain
@@ -49,12 +51,18 @@ message Plan {
 message SoftwareUpgradeProposal {
   option deprecated                          = true;
   option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
+  option (amino.name)                        = "cosmos-sdk/SoftwareUpgradeProposal";
   option (gogoproto.equal)                   = true;
   option (gogoproto.goproto_stringer)        = false;
 
-  string title       = 1;
+  // title of the proposal
+  string title = 1;
+
+  // description of the proposal
   string description = 2;
-  Plan   plan        = 3 [(gogoproto.nullable) = false];
+
+  // plan of the proposal
+  Plan plan = 3 [(gogoproto.nullable) = false, (amino.dont_omitempty) = true];
 }
 
 // CancelSoftwareUpgradeProposal is a gov Content type for cancelling a software
@@ -64,10 +72,14 @@ message SoftwareUpgradeProposal {
 message CancelSoftwareUpgradeProposal {
   option deprecated                          = true;
   option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
+  option (amino.name)                        = "cosmos-sdk/CancelSoftwareUpgradeProposal";
   option (gogoproto.equal)                   = true;
   option (gogoproto.goproto_stringer)        = false;
 
-  string title       = 1;
+  // title of the proposal
+  string title = 1;
+
+  // description of the proposal
   string description = 2;
 }
 

package/third_party/proto/cosmos_proto/cosmos.proto

@@ -5,6 +5,12 @@ import "google/protobuf/descriptor.proto";
 
 option go_package = "github.com/cosmos/cosmos-proto;cosmos_proto";
 
+extend google.protobuf.MethodOptions {    
+    
+    // method_added_in is used to indicate from which version the method was added.
+    string method_added_in = 93001;
+}
+
 extend google.protobuf.MessageOptions {
 
     // implements_interface is used to indicate the type name of the interface
@@ -13,6 +19,9 @@ extend google.protobuf.MessageOptions {
     // interfaces. Interfaces should be declared using a declare_interface
     // file option.
     repeated string implements_interface = 93001;
+
+    // message_added_in is used to indicate from which version the message was added.
+    string message_added_in = 93002;
 }
 
 extend google.protobuf.FieldOptions {
@@ -27,6 +36,9 @@ extend google.protobuf.FieldOptions {
     // generators may choose to use this information to map this field to a
     // language-specific type representing the scalar.
     string scalar = 93002;
+
+    // field_added_in is used to indicate from which version the field was added.
+    string field_added_in = 93003;
 }
 
 extend google.protobuf.FileOptions {
@@ -46,6 +58,9 @@ extend google.protobuf.FileOptions {
     // expected that the declaration will be found in a protobuf file named
     // a/b/scalars.proto in the file descriptor set.
     repeated ScalarDescriptor declare_scalar = 793022;
+
+    // file_added_in is used to indicate from which the version the file was added.
+    string file_added_in = 793023;
 }
 
 // InterfaceDescriptor describes an interface type to be used with
@@ -94,4 +109,4 @@ enum ScalarType {
     SCALAR_TYPE_UNSPECIFIED = 0;
     SCALAR_TYPE_STRING = 1;
     SCALAR_TYPE_BYTES = 2;
-}
+}

package/third_party/proto/gogoproto/gogo.proto

@@ -1,7 +1,7 @@
 // Protocol Buffers for Go with Gadgets
 //
 // Copyright (c) 2013, The GoGo Authors. All rights reserved.
-// http://github.com/gogo/protobuf
+// http://github.com/cosmos/gogoproto
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@ import "google/protobuf/descriptor.proto";
 
 option java_package = "com.google.protobuf";
 option java_outer_classname = "GoGoProtos";
-option go_package = "github.com/gogo/protobuf/gogoproto";
+option go_package = "github.com/cosmos/gogoproto/gogoproto";
 
 extend google.protobuf.EnumOptions {
 	optional bool goproto_enum_prefix = 62001;

package/third_party/proto/google/protobuf/any.proto

@@ -33,7 +33,7 @@ syntax = "proto3";
 package google.protobuf;
 
 option csharp_namespace = "Google.Protobuf.WellKnownTypes";
-option go_package = "types";
+option go_package = "google.golang.org/protobuf/types/known/anypb";
 option java_package = "com.google.protobuf";
 option java_outer_classname = "AnyProto";
 option java_multiple_files = true;
@@ -77,10 +77,13 @@ option objc_class_prefix = "GPB";
 //  Example 4: Pack and unpack a message in Go
 //
 //      foo := &pb.Foo{...}
-//      any, err := ptypes.MarshalAny(foo)
+//      any, err := anypb.New(foo)
+//      if err != nil {
+//        ...
+//      }
 //      ...
 //      foo := &pb.Foo{}
-//      if err := ptypes.UnmarshalAny(any, foo); err != nil {
+//      if err := any.UnmarshalTo(foo); err != nil {
 //        ...
 //      }
 //

package/third_party/proto/ibc/core/channel/v1/channel.proto

@@ -2,7 +2,7 @@ syntax = "proto3";
 
 package ibc.core.channel.v1;
 
-option go_package = "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types";
+option go_package = "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types";
 
 import "gogoproto/gogo.proto";
 import "ibc/core/client/v1/client.proto";

package/third_party/proto/ibc/core/client/v1/client.proto

@@ -2,7 +2,7 @@ syntax = "proto3";
 
 package ibc.core.client.v1;
 
-option go_package = "github.com/cosmos/ibc-go/v6/modules/core/02-client/types";
+option go_package = "github.com/cosmos/ibc-go/v7/modules/core/02-client/types";
 
 import "gogoproto/gogo.proto";
 import "google/protobuf/any.proto";
@@ -98,6 +98,8 @@ message Height {
 
 // Params defines the set of IBC light client parameters.
 message Params {
-  // allowed_clients defines the list of allowed client state types.
+  // allowed_clients defines the list of allowed client state types which can be created
+  // and interacted with. If a client type is removed from the allowed clients list, usage
+  // of this client will be disabled until it is added again to the list.
   repeated string allowed_clients = 1 [(gogoproto.moretags) = "yaml:\"allowed_clients\""];
 }

package/types/address_hooks.go

@@ -7,10 +7,8 @@ import (
 	"github.com/cosmos/cosmos-sdk/codec"
 	"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"
+	transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types"
+	ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported"
 )
 
 type AddressRole string
@@ -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

@@ -8,11 +8,11 @@ import (
 	codec "github.com/cosmos/cosmos-sdk/codec"
 	cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
 
-	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"
+	transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types"
+	clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types"
+	channeltypes "github.com/cosmos/ibc-go/v7/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: