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

package/tests/integrations/vbank/vbank_test.go

@@ -0,0 +1,348 @@
+package vbank_test
+
+import (
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	appmodule "cosmossdk.io/core/appmodule"
+	"cosmossdk.io/log"
+	sdkmath "cosmossdk.io/math"
+	storetypes "cosmossdk.io/store/types"
+	"github.com/cometbft/cometbft/crypto/secp256k1"
+	cmtproto "github.com/cometbft/cometbft/proto/tendermint/types"
+	"github.com/cosmos/cosmos-sdk/codec"
+	addresscodec "github.com/cosmos/cosmos-sdk/codec/address"
+	"github.com/cosmos/cosmos-sdk/runtime"
+	"github.com/cosmos/cosmos-sdk/testutil/integration"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"
+	"github.com/cosmos/cosmos-sdk/x/auth"
+	authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
+	authsims "github.com/cosmos/cosmos-sdk/x/auth/simulation"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	"github.com/cosmos/cosmos-sdk/x/bank"
+	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+	minttypes "github.com/cosmos/cosmos-sdk/x/mint/types"
+	paramskeeper "github.com/cosmos/cosmos-sdk/x/params/keeper"
+	paramstypes "github.com/cosmos/cosmos-sdk/x/params/types"
+	"github.com/stretchr/testify/require"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vbank"
+	vbanktypes "github.com/Agoric/agoric-sdk/golang/cosmos/x/vbank/types"
+
+	vstorage "github.com/Agoric/agoric-sdk/golang/cosmos/x/vstorage"
+)
+
+var (
+	priv1 = secp256k1.GenPrivKey()
+	priv2 = secp256k1.GenPrivKey()
+	priv3 = secp256k1.GenPrivKey()
+	priv4 = secp256k1.GenPrivKey()
+	addr1 = sdk.AccAddress(priv1.PubKey().Address()).String()
+	addr2 = sdk.AccAddress(priv2.PubKey().Address()).String()
+	addr3 = sdk.AccAddress(priv3.PubKey().Address()).String()
+	addr4 = sdk.AccAddress(priv4.PubKey().Address()).String()
+)
+
+type VbankFixtures struct {
+	ctx         sdk.Context
+	vbankKeeper vbank.Keeper
+	bankKeeper  bankkeeper.Keeper
+	vbankModule vbank.AppModule
+	bankModule  bank.AppModule
+}
+
+func (f *VbankFixtures) advanceBlock(t *testing.T) {
+	currentHeight := f.ctx.BlockHeight()
+	currentTime := f.ctx.BlockTime()
+
+	f.ctx = f.ctx.WithBlockHeight(currentHeight + 1).WithBlockTime(currentTime.Add(5 * time.Second))
+
+	err := f.vbankModule.EndBlock(f.ctx)
+
+	require.NoError(t, err)
+
+}
+
+func initVbankFixtures(t *testing.T) VbankFixtures {
+	// Create encoding config with all required modules
+	encodingCfg := moduletestutil.MakeTestEncodingConfig(
+		auth.AppModuleBasic{},
+		bank.AppModuleBasic{},
+		vbank.AppModuleBasic{},
+	)
+
+	// Define all required store keys
+	keys := storetypes.NewKVStoreKeys(
+		authtypes.StoreKey,
+		banktypes.StoreKey,
+		vbank.StoreKey,
+		paramstypes.StoreKey,
+		vstorage.StoreKey,
+		swingset.StoreKey,
+	)
+	tkeys := storetypes.NewTransientStoreKeys(
+		vbanktypes.TStoreKey,
+		paramstypes.TStoreKey,
+	)
+
+	logger := log.NewTestLogger(t)
+	cms := integration.CreateMultiStore(keys, logger)
+
+	// Mount transient stores manually
+	for _, tkey := range tkeys {
+		cms.MountStoreWithDB(tkey, storetypes.StoreTypeTransient, nil)
+	}
+
+	// Load latest version after mounting stores
+	if err := cms.LoadLatestVersion(); err != nil {
+		t.Fatalf("failed to load multistore: %v", err)
+	}
+
+	newCtx := sdk.NewContext(cms, cmtproto.Header{}, true, logger)
+	authority := authtypes.NewModuleAddress("gov")
+
+	maccPerms := map[string][]string{
+		minttypes.ModuleName:         {authtypes.Minter},
+		vbank.ModuleName:             {authtypes.Burner, authtypes.Staking},
+		vbanktypes.ReservePoolName:   nil,
+		vbanktypes.ProvisionPoolName: nil,
+		vbanktypes.GiveawayPoolName:  nil,
+	}
+
+	// Initialize all keepers
+	accountKeeper := authkeeper.NewAccountKeeper(
+		encodingCfg.Codec,
+		runtime.NewKVStoreService(keys[authtypes.StoreKey]),
+		authtypes.ProtoBaseAccount,
+		maccPerms,
+		addresscodec.NewBech32Codec(sdk.Bech32MainPrefix),
+		sdk.Bech32MainPrefix,
+		authority.String(),
+	)
+
+	blockedAddresses := BlockedAddresses(maccPerms)
+
+	bankKeeper := bankkeeper.NewBaseKeeper(
+		encodingCfg.Codec,
+		runtime.NewKVStoreService(keys[banktypes.StoreKey]),
+		accountKeeper,
+		blockedAddresses,
+		authority.String(),
+		logger,
+	)
+
+	vstorageKeeper := vstorage.NewKeeper(
+		vstorage.StoreKey,
+		runtime.NewKVStoreService(keys[vstorage.StoreKey]),
+	)
+
+	paramsKeeper := initParamsKeeper(encodingCfg.Codec, codec.NewLegacyAmino(), keys[paramstypes.StoreKey], tkeys[paramstypes.TStoreKey])
+
+	// Dummy controller function for testing
+	callToController := func(ctx sdk.Context, jsonRequest string) (jsonReply string, err error) {
+		return `{"ok": true}`, nil
+	}
+
+	// Initialize swingset keeper
+	swingSetKeeper := swingset.NewKeeper(
+		encodingCfg.Codec,
+		runtime.NewKVStoreService(keys[swingset.StoreKey]),
+		getSubspace(swingset.ModuleName, paramsKeeper),
+		accountKeeper,
+		bankKeeper,
+		vstorageKeeper,
+		vbanktypes.ReservePoolName,
+		callToController,
+	)
+
+	// Initialize vbank keeper
+	vbankKeeper := vbank.NewKeeper(
+		encodingCfg.Codec,
+		runtime.NewKVStoreService(keys[vbank.StoreKey]),
+		runtime.NewTransientStoreService(tkeys[vbanktypes.TStoreKey]),
+		getSubspace(vbank.ModuleName, paramsKeeper),
+		accountKeeper,
+		bankKeeper,
+		authtypes.FeeCollectorName,
+		swingSetKeeper.PushAction,
+	)
+
+	// Create app modules
+	authModule := auth.NewAppModule(
+		encodingCfg.Codec,
+		accountKeeper,
+		authsims.RandomGenesisAccounts,
+		getSubspace(authtypes.ModuleName, paramsKeeper),
+	)
+	bankModule := bank.NewAppModule(
+		encodingCfg.Codec,
+		bankKeeper,
+		accountKeeper,
+		getSubspace(banktypes.ModuleName, paramsKeeper),
+	)
+	vbankModule := vbank.NewAppModule(vbankKeeper)
+
+	// Create integration app
+	integrationApp := integration.NewIntegrationApp(
+		newCtx,
+		logger,
+		keys,
+		encodingCfg.Codec,
+		map[string]appmodule.AppModule{
+			authtypes.ModuleName: authModule,
+			banktypes.ModuleName: bankModule,
+			vbank.ModuleName:     vbankModule,
+		},
+	)
+
+	// Get the SDK context from the integration app
+	sdkCtx := sdk.UnwrapSDKContext(integrationApp.Context())
+
+	// Register message and query servers
+	vbanktypes.RegisterMsgServer(integrationApp.MsgServiceRouter(), vbanktypes.UnimplementedMsgServer{})
+	vbanktypes.RegisterQueryServer(integrationApp.QueryHelper(), &vbanktypes.UnimplementedQueryServer{})
+
+	return VbankFixtures{
+		ctx:         sdkCtx,
+		vbankKeeper: vbankKeeper,
+		bankKeeper:  bankKeeper,
+		vbankModule: vbankModule,
+		bankModule:  bankModule,
+	}
+}
+
+// BlockedAddresses returns the app's module account addresses that
+// are blocked from receiving funds.
+func BlockedAddresses(maccPerms map[string][]string) map[string]bool {
+	modAccAddrs := make(map[string]bool)
+	for acc := range maccPerms {
+		// The provision and reserve pools are not blocked from receiving funds.
+		// NOTE: because of this, these pools must be explicitly
+		// initialized as module accounts during bootstrap to avoid
+		// implicit creation as a default account when funds are received.
+		switch acc {
+		case vbanktypes.ProvisionPoolName, vbanktypes.ReservePoolName:
+			continue
+		}
+		modAccAddrs[authtypes.NewModuleAddress(acc).String()] = true
+	}
+
+	return modAccAddrs
+}
+
+func getSubspace(moduleName string, paramsKeeper paramskeeper.Keeper) paramstypes.Subspace {
+	subspace, _ := paramsKeeper.GetSubspace(moduleName)
+	return subspace
+}
+
+// initParamsKeeper init params keeper and its subspaces
+func initParamsKeeper(appCodec codec.BinaryCodec, legacyAmino *codec.LegacyAmino, key, tkey storetypes.StoreKey) paramskeeper.Keeper {
+	paramsKeeper := paramskeeper.NewKeeper(appCodec, legacyAmino, key, tkey)
+
+	paramsKeeper.Subspace(authtypes.ModuleName)
+	paramsKeeper.Subspace(banktypes.ModuleName)
+	paramsKeeper.Subspace(minttypes.ModuleName)
+	paramsKeeper.Subspace(swingset.ModuleName)
+	paramsKeeper.Subspace(vbank.ModuleName)
+
+	return paramsKeeper
+}
+
+func Test_EndBlock_Events(t *testing.T) {
+	t.Parallel()
+	f := initVbankFixtures(t)
+
+	addr1 := sdk.AccAddress(priv1.PubKey().Address())
+	addr2 := sdk.AccAddress(priv2.PubKey().Address())
+	addr4 := sdk.AccAddress(priv4.PubKey().Address())
+
+	adStore := f.vbankKeeper.OpenAddressToUpdateStore(f.ctx)
+
+	t.Log("Address Update Store contents before:")
+	preCount := 0
+	iterator := adStore.Iterator(nil, nil)
+	for ; iterator.Valid(); iterator.Next() {
+		addressBytes := iterator.Key()
+		denoms := string(iterator.Value())
+
+		// Convert raw address bytes to bech32 format for readability
+		address, err := f.vbankKeeper.AddressCodec().BytesToString(addressBytes)
+		if err != nil {
+			address = fmt.Sprintf("(invalid address: %x)", addressBytes)
+		}
+
+		fmt.Fprintf(os.Stderr, "Address: %s, Denoms: %s\n", address, denoms)
+		t.Logf("Address: %s, Denoms: %s", address, denoms)
+		preCount++
+	}
+	iterator.Close()
+
+	require.Equal(t, preCount, 0)
+
+	// Mint and distribute coins to match unit test setup
+	// addr1: 1000 ubld
+	f.bankKeeper.MintCoins(f.ctx, "mint", sdk.NewCoins(sdk.NewInt64Coin("ubld", 1000)))
+	f.bankKeeper.SendCoinsFromModuleToAccount(f.ctx, "mint", addr1, sdk.NewCoins(sdk.NewInt64Coin("ubld", 1000)))
+
+	// addr2: 4000 urun and 7 arcadeTokens
+	f.bankKeeper.MintCoins(f.ctx, "mint", sdk.NewCoins(
+		sdk.NewInt64Coin("urun", 4000),
+		sdk.NewInt64Coin("arcadeTokens", 7),
+	))
+
+	f.bankKeeper.SendCoinsFromModuleToAccount(f.ctx, "mint", addr2, sdk.NewCoins(
+		sdk.NewInt64Coin("urun", 4000),
+		sdk.NewInt64Coin("arcadeTokens", 7),
+	))
+
+	// addr1 send to addr4: 1000 urun
+	f.bankKeeper.SendCoins(f.ctx, addr1, addr4, sdk.NewCoins(sdk.NewInt64Coin("ubld", 1000)))
+
+	// Set params
+	f.vbankKeeper.SetParams(f.ctx, vbanktypes.Params{
+		PerEpochRewardFraction:    sdkmath.LegacyZeroDec(),
+		AllowedMonitoringAccounts: []string{"*"},
+	})
+
+	// Get the address update store
+	f.advanceBlock(t)
+	adStore = f.vbankKeeper.OpenAddressToUpdateStore(f.ctx)
+
+	// Print all entries in the store
+	iterator = adStore.Iterator(nil, nil)
+	defer iterator.Close()
+	postCount := 0
+
+	t.Logf("addr1: %s", addr1)
+	t.Logf("addr2: %s", addr2)
+	t.Logf("addr3: %s", addr3)
+	t.Logf("addr4: %s", addr4)
+	t.Logf("mint: %s", authtypes.NewModuleAddress("mint"))
+	expected := map[string]string{
+		addr1.String(): "2000ubld",
+		addr2.String(): "7arcadeTokens,4000urun",
+		addr4.String(): "1000ubld",
+		authtypes.NewModuleAddress("mint").String(): "7arcadeTokens,1000ubld,4000urun",
+	}
+
+	for ; iterator.Valid(); iterator.Next() {
+		addressBytes := iterator.Key()
+		denoms := string(iterator.Value())
+
+		// Convert raw address bytes to bech32 format for readability
+		address, err := f.vbankKeeper.AddressCodec().BytesToString(addressBytes)
+		if err != nil {
+			address = fmt.Sprintf("(invalid address: %x)", addressBytes)
+		}
+
+		require.Equal(t, expected[address], denoms)
+
+		postCount++
+	}
+
+}

package/third_party/proto/amino/amino.proto

@@ -76,4 +76,9 @@ extend google.protobuf.FieldOptions {
   // out := AminoJSONEncoder(&f);
   // out == {"baz":""}
   bool dont_omitempty = 11110005;
-}
+
+  // oneof_name sets the type name for the given field oneof field.  This is used
+  // by the Amino JSON encoder to encode the type of the oneof field, and must be the same string in
+  // the RegisterConcrete() method usage used to register the concrete type.
+  string oneof_name = 11110006;
+}

package/third_party/proto/cosmos/base/v1beta1/coin.proto

@@ -19,7 +19,7 @@ message Coin {
   string denom  = 1;
   string amount = 2 [
     (cosmos_proto.scalar)  = "cosmos.Int",
-    (gogoproto.customtype) = "Int",
+    (gogoproto.customtype) = "cosmossdk.io/math.Int",
     (gogoproto.nullable)   = false,
     (amino.dont_omitempty) = true
   ];
@@ -33,16 +33,29 @@ message DecCoin {
   option (gogoproto.equal) = true;
 
   string denom  = 1;
-  string amount = 2
-      [(cosmos_proto.scalar) = "cosmos.Dec", (gogoproto.customtype) = "Dec", (gogoproto.nullable) = false];
+  string amount = 2 [
+    (cosmos_proto.scalar)  = "cosmos.Dec",
+    (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
+    (gogoproto.nullable)   = false
+  ];
 }
 
 // IntProto defines a Protobuf wrapper around an Int object.
+// Deprecated: Prefer to use math.Int directly. It supports binary Marshal and Unmarshal.
 message IntProto {
-  string int = 1 [(cosmos_proto.scalar) = "cosmos.Int", (gogoproto.customtype) = "Int", (gogoproto.nullable) = false];
+  string int = 1 [
+    (cosmos_proto.scalar)  = "cosmos.Int",
+    (gogoproto.customtype) = "cosmossdk.io/math.Int",
+    (gogoproto.nullable)   = false
+  ];
 }
 
 // DecProto defines a Protobuf wrapper around a Dec object.
+// Deprecated: Prefer to use math.LegacyDec directly. It supports binary Marshal and Unmarshal.
 message DecProto {
-  string dec = 1 [(cosmos_proto.scalar) = "cosmos.Dec", (gogoproto.customtype) = "Dec", (gogoproto.nullable) = false];
+  string dec = 1 [
+    (cosmos_proto.scalar)  = "cosmos.Dec",
+    (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
+    (gogoproto.nullable)   = false
+  ];
 }

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

@@ -7,14 +7,13 @@ 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 go_package                      = "cosmossdk.io/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;
+  option (amino.name)      = "cosmos-sdk/Plan";
+  option (gogoproto.equal) = true;
 
   // Sets the name for the upgrade. This name will be used by the upgraded
   // version of the software to apply any special "on-upgrade" commands during
@@ -53,7 +52,6 @@ message SoftwareUpgradeProposal {
   option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
   option (amino.name)                        = "cosmos-sdk/SoftwareUpgradeProposal";
   option (gogoproto.equal)                   = true;
-  option (gogoproto.goproto_stringer)        = false;
 
   // title of the proposal
   string title = 1;
@@ -74,7 +72,6 @@ message CancelSoftwareUpgradeProposal {
   option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
   option (amino.name)                        = "cosmos-sdk/CancelSoftwareUpgradeProposal";
   option (gogoproto.equal)                   = true;
-  option (gogoproto.goproto_stringer)        = false;
 
   // title of the proposal
   string title = 1;
@@ -87,8 +84,7 @@ message CancelSoftwareUpgradeProposal {
 //
 // Since: cosmos-sdk 0.43
 message ModuleVersion {
-  option (gogoproto.equal)            = true;
-  option (gogoproto.goproto_stringer) = true;
+  option (gogoproto.equal) = true;
 
   // name of the app module
   string name = 1;

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/v7/modules/core/04-channel/types";
+option go_package = "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types";
 
 import "gogoproto/gogo.proto";
 import "ibc/core/client/v1/client.proto";
@@ -21,9 +21,12 @@ message Channel {
   Counterparty counterparty = 3 [(gogoproto.nullable) = false];
   // list of connection identifiers, in order, along which packets sent on
   // this channel will travel
-  repeated string connection_hops = 4 [(gogoproto.moretags) = "yaml:\"connection_hops\""];
+  repeated string connection_hops = 4;
   // opaque channel version, which is agreed upon during the handshake
   string version = 5;
+  // upgrade sequence indicates the latest upgrade attempt performed by this channel
+  // the value of 0 indicates the channel has never been upgraded
+  uint64 upgrade_sequence = 6;
 }
 
 // IdentifiedChannel defines a channel with additional port and channel
@@ -39,17 +42,20 @@ message IdentifiedChannel {
   Counterparty counterparty = 3 [(gogoproto.nullable) = false];
   // list of connection identifiers, in order, along which packets sent on
   // this channel will travel
-  repeated string connection_hops = 4 [(gogoproto.moretags) = "yaml:\"connection_hops\""];
+  repeated string connection_hops = 4;
   // opaque channel version, which is agreed upon during the handshake
   string version = 5;
   // port identifier
   string port_id = 6;
   // channel identifier
   string channel_id = 7;
+  // upgrade sequence indicates the latest upgrade attempt performed by this channel
+  // the value of 0 indicates the channel has never been upgraded
+  uint64 upgrade_sequence = 8;
 }
 
 // State defines if a channel is in one of the following states:
-// CLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.
+// CLOSED, INIT, TRYOPEN, OPEN, FLUSHING, FLUSHCOMPLETE or UNINITIALIZED.
 enum State {
   option (gogoproto.goproto_enum_prefix) = false;
 
@@ -65,6 +71,10 @@ enum State {
   // A channel has been closed and can no longer be used to send or receive
   // packets.
   STATE_CLOSED = 4 [(gogoproto.enumvalue_customname) = "CLOSED"];
+  // A channel has just accepted the upgrade handshake attempt and is flushing in-flight packets.
+  STATE_FLUSHING = 5 [(gogoproto.enumvalue_customname) = "FLUSHING"];
+  // A channel has just completed flushing any in-flight packets.
+  STATE_FLUSHCOMPLETE = 6 [(gogoproto.enumvalue_customname) = "FLUSHCOMPLETE"];
 }
 
 // Order defines if a channel is ORDERED or UNORDERED
@@ -85,9 +95,9 @@ message Counterparty {
   option (gogoproto.goproto_getters) = false;
 
   // port on the counterparty chain which owns the other end of the channel.
-  string port_id = 1 [(gogoproto.moretags) = "yaml:\"port_id\""];
+  string port_id = 1;
   // channel end on the counterparty chain
-  string channel_id = 2 [(gogoproto.moretags) = "yaml:\"channel_id\""];
+  string channel_id = 2;
 }
 
 // Packet defines a type that carries data across different chains through IBC
@@ -99,20 +109,19 @@ message Packet {
   // with a later sequence number.
   uint64 sequence = 1;
   // identifies the port on the sending chain.
-  string source_port = 2 [(gogoproto.moretags) = "yaml:\"source_port\""];
+  string source_port = 2;
   // identifies the channel end on the sending chain.
-  string source_channel = 3 [(gogoproto.moretags) = "yaml:\"source_channel\""];
+  string source_channel = 3;
   // identifies the port on the receiving chain.
-  string destination_port = 4 [(gogoproto.moretags) = "yaml:\"destination_port\""];
+  string destination_port = 4;
   // identifies the channel end on the receiving chain.
-  string destination_channel = 5 [(gogoproto.moretags) = "yaml:\"destination_channel\""];
+  string destination_channel = 5;
   // actual opaque bytes transferred directly to the application module
   bytes data = 6;
   // block height after which the packet times out
-  ibc.core.client.v1.Height timeout_height = 7
-      [(gogoproto.moretags) = "yaml:\"timeout_height\"", (gogoproto.nullable) = false];
+  ibc.core.client.v1.Height timeout_height = 7 [(gogoproto.nullable) = false];
   // block timestamp (in nanoseconds) after which the packet times out
-  uint64 timeout_timestamp = 8 [(gogoproto.moretags) = "yaml:\"timeout_timestamp\""];
+  uint64 timeout_timestamp = 8;
 }
 
 // PacketState defines the generic type necessary to retrieve and store
@@ -123,9 +132,9 @@ message PacketState {
   option (gogoproto.goproto_getters) = false;
 
   // channel port identifier.
-  string port_id = 1 [(gogoproto.moretags) = "yaml:\"port_id\""];
+  string port_id = 1;
   // channel unique identifier.
-  string channel_id = 2 [(gogoproto.moretags) = "yaml:\"channel_id\""];
+  string channel_id = 2;
   // packet sequence.
   uint64 sequence = 3;
   // embedded data that represents packet state.
@@ -139,9 +148,9 @@ message PacketId {
   option (gogoproto.goproto_getters) = false;
 
   // channel port identifier
-  string port_id = 1 [(gogoproto.moretags) = "yaml:\"port_id\""];
+  string port_id = 1;
   // channel unique identifier
-  string channel_id = 2 [(gogoproto.moretags) = "yaml:\"channel_id\""];
+  string channel_id = 2;
   // packet sequence
   uint64 sequence = 3;
 }
@@ -160,3 +169,19 @@ message Acknowledgement {
     string error  = 22;
   }
 }
+
+// Timeout defines an execution deadline structure for 04-channel handlers.
+// This includes packet lifecycle handlers as well as the upgrade handshake handlers.
+// A valid Timeout contains either one or both of a timestamp and block height (sequence).
+message Timeout {
+  // block height after which the packet or upgrade times out
+  ibc.core.client.v1.Height height = 1 [(gogoproto.nullable) = false];
+  // block timestamp (in nanoseconds) after which the packet or upgrade times out
+  uint64 timestamp = 2;
+}
+
+// Params defines the set of IBC channel parameters.
+message Params {
+  // the relative timeout after which channel upgrades will time out.
+  Timeout upgrade_timeout = 1 [(gogoproto.nullable) = false];
+}