wormchain: setparams gov vaa (#3285)

* node: add new governance VAA for setting default tokenfactory and packet forward middleware params on Gateway

* wormchain: add msg_server handler to set default tokenfactory and pfm params

* node: add gateway template command

* node: fix lint errors

* Update goverance message to be generic

* x/wormhole: add RunInPlaceUpgrade tx cli command

* Merge gateway governance VAAs into a single rpc handler

* update admin client naming for gateway governance messages

node/cmd/guardiand/admintemplate.go

@@ -48,7 +48,7 @@ var wormchainMigrateContractInstantiationMsg *string
 var wormchainWasmInstantiateAllowlistCodeId *string
 var wormchainWasmInstantiateAllowlistContractAddress *string
 
-var wormchainIbcComposabilityMwContractAddress *string
+var gatewayIbcComposabilityMwContractAddress *string
 
 var ibcUpdateChannelChainTargetChainId *string
 var ibcUpdateChannelChainChannelId *string
@@ -132,11 +132,11 @@ func init() {
 	TemplateCmd.AddCommand(AdminClientWormchainAddWasmInstantiateAllowlistCmd)
 	TemplateCmd.AddCommand(AdminClientWormchainDeleteWasmInstantiateAllowlistCmd)
 
-	// flags for the wormchain-ibc-composability-mw-set-contract command
-	wormchainIbcComposabilityMwFlagSet := pflag.NewFlagSet("wormchain-ibc-composability-mw-set-contract", pflag.ExitOnError)
-	wormchainIbcComposabilityMwContractAddress = wormchainIbcComposabilityMwFlagSet.String("contract-address", "", "contract address to set in the ibc composability middleware")
-	AdminClientWormchainIbcComposabilityMwSetContractCmd.Flags().AddFlagSet(wormchainIbcComposabilityMwFlagSet)
-	TemplateCmd.AddCommand(AdminClientWormchainIbcComposabilityMwSetContractCmd)
+	// flags for the gateway-ibc-composability-mw-set-contract command
+	gatewayIbcComposabilityMwFlagSet := pflag.NewFlagSet("gateway-ibc-composability-mw-set-contract", pflag.ExitOnError)
+	gatewayIbcComposabilityMwContractAddress = gatewayIbcComposabilityMwFlagSet.String("contract-address", "", "contract address to set in the ibc composability middleware")
+	AdminClientGatewayIbcComposabilityMwSetContractCmd.Flags().AddFlagSet(gatewayIbcComposabilityMwFlagSet)
+	TemplateCmd.AddCommand(AdminClientGatewayIbcComposabilityMwSetContractCmd)
 
 	// flags for the ibc-receiver-update-channel-chain and ibc-translator-update-channel-chain commands
 	ibcUpdateChannelChainFlagSet := pflag.NewFlagSet("ibc-mapping", pflag.ExitOnError)
@@ -147,6 +147,9 @@ func init() {
 	AdminClientIbcTranslatorUpdateChannelChainCmd.Flags().AddFlagSet(ibcUpdateChannelChainFlagSet)
 	TemplateCmd.AddCommand(AdminClientIbcReceiverUpdateChannelChainCmd)
 	TemplateCmd.AddCommand(AdminClientIbcTranslatorUpdateChannelChainCmd)
+
+	// AdminClientGatewaySetTokenfactoryPfmDefaultParamsCmd doesn't have any flags
+	TemplateCmd.AddCommand(AdminClientGatewaySetTokenfactoryPfmDefaultParamsCmd)
 }
 
 var TemplateCmd = &cobra.Command{
@@ -226,10 +229,16 @@ var AdminClientWormchainDeleteWasmInstantiateAllowlistCmd = &cobra.Command{
 	Run:   runWormchainDeleteWasmInstantiateAllowlistTemplate,
 }
 
-var AdminClientWormchainIbcComposabilityMwSetContractCmd = &cobra.Command{
-	Use:   "wormchain-ibc-composability-mw-set-contract",
+var AdminClientGatewayIbcComposabilityMwSetContractCmd = &cobra.Command{
+	Use:   "gateway-ibc-composability-mw-set-contract",
 	Short: "Set the contract that the IBC Composability middleware will query",
-	Run:   runWormchainIbcComposabilityMwSetContractTemplate,
+	Run:   runGatewayIbcComposabilityMwSetContractTemplate,
+}
+
+var AdminClientGatewaySetTokenfactoryPfmDefaultParamsCmd = &cobra.Command{
+	Use:   "gateway-set-tokenfactory-pfm-default-params",
+	Short: "Generate an empty gateway set tokenfactory pfm default params template at specified path",
+	Run:   runGatewaySetTokenfactoryPfmDefaultParamsTemplate,
 }
 
 var AdminClientIbcReceiverUpdateChannelChainCmd = &cobra.Command{
@@ -674,8 +683,8 @@ func runWormchainWasmInstantiateAllowlistTemplate(action nodev1.WormchainWasmIns
 	fmt.Print(string(b))
 }
 
-func runWormchainIbcComposabilityMwSetContractTemplate(cmd *cobra.Command, args []string) {
-	if *wormchainIbcComposabilityMwContractAddress == "" {
+func runGatewayIbcComposabilityMwSetContractTemplate(cmd *cobra.Command, args []string) {
+	if *gatewayIbcComposabilityMwContractAddress == "" {
 		log.Fatal("--contract-address must be specified")
 	}
 
@@ -685,9 +694,9 @@ func runWormchainIbcComposabilityMwSetContractTemplate(cmd *cobra.Command, args
 			{
 				Sequence: rand.Uint64(),
 				Nonce:    rand.Uint32(),
-				Payload: &nodev1.GovernanceMessage_WormchainIbcComposabilityMwSetContract{
-					WormchainIbcComposabilityMwSetContract: &nodev1.WormchainIbcComposabilityMwSetContract{
-						Contract: *wormchainIbcComposabilityMwContractAddress,
+				Payload: &nodev1.GovernanceMessage_GatewayIbcComposabilityMwSetContract{
+					GatewayIbcComposabilityMwSetContract: &nodev1.GatewayIbcComposabilityMwSetContract{
+						Contract: *gatewayIbcComposabilityMwContractAddress,
 					},
 				},
 			},
@@ -701,6 +710,27 @@ func runWormchainIbcComposabilityMwSetContractTemplate(cmd *cobra.Command, args
 	fmt.Print(string(b))
 }
 
+func runGatewaySetTokenfactoryPfmDefaultParamsTemplate(cmd *cobra.Command, args []string) {
+	m := &nodev1.InjectGovernanceVAARequest{
+		CurrentSetIndex: uint32(*templateGuardianIndex),
+		Messages: []*nodev1.GovernanceMessage{
+			{
+				Sequence: rand.Uint64(),
+				Nonce:    rand.Uint32(),
+				Payload: &nodev1.GovernanceMessage_GatewaySetTokenfactoryPfmDefaultParams{
+					GatewaySetTokenfactoryPfmDefaultParams: &nodev1.GatewaySetTokenfactoryPfmDefaultParams{},
+				},
+			},
+		},
+	}
+
+	b, err := prototext.MarshalOptions{Multiline: true}.Marshal(m)
+	if err != nil {
+		panic(err)
+	}
+	fmt.Print(string(b))
+}
+
 func runIbcReceiverUpdateChannelChainTemplate(cmd *cobra.Command, args []string) {
 	runIbcUpdateChannelChainTemplate(nodev1.IbcUpdateChannelChainModule_IBC_UPDATE_CHANNEL_CHAIN_MODULE_RECEIVER)
 }

node/pkg/adminrpc/adminserver.go

@@ -338,8 +338,8 @@ func wormchainWasmInstantiateAllowlist(
 	return v, nil
 }
 
-func wormchainIbcComposabilityMwSetContract(
-	req *nodev1.WormchainIbcComposabilityMwSetContract,
+func gatewayIbcComposabilityMwSetContract(
+	req *nodev1.GatewayIbcComposabilityMwSetContract,
 	timestamp time.Time,
 	guardianSetIndex uint32,
 	nonce uint32,
@@ -353,13 +353,30 @@ func wormchainIbcComposabilityMwSetContract(
 	var decodedAddr32 [32]byte
 	copy(decodedAddr32[:], decodedAddr)
 
-	v := vaa.CreateGovernanceVAA(timestamp, nonce, sequence, guardianSetIndex, vaa.BodyWormchainIbcComposabilityMwContract{
+	v := vaa.CreateGovernanceVAA(timestamp, nonce, sequence, guardianSetIndex, vaa.BodyGatewayIbcComposabilityMwContract{
 		ContractAddr: decodedAddr32,
 	}.Serialize())
 
 	return v, nil
 }
 
+func gatewaySetTokenfactoryPfmDefaultParams(
+	timestamp time.Time,
+	guardianSetIndex uint32,
+	nonce uint32,
+	sequence uint64,
+) *vaa.VAA {
+	v := vaa.CreateGovernanceVAA(
+		timestamp,
+		nonce,
+		sequence,
+		guardianSetIndex,
+		vaa.EmptyPayloadVaa(vaa.GatewayModuleStr, vaa.ActionSetTokenfactoryPfmDefaultParams, vaa.ChainIDWormchain),
+	)
+
+	return v
+}
+
 // circleIntegrationUpdateWormholeFinality converts a nodev1.CircleIntegrationUpdateWormholeFinality to its canonical VAA representation
 // Returns an error if the data is invalid
 func circleIntegrationUpdateWormholeFinality(req *nodev1.CircleIntegrationUpdateWormholeFinality, timestamp time.Time, guardianSetIndex uint32, nonce uint32, sequence uint64) (*vaa.VAA, error) {
@@ -531,8 +548,10 @@ func GovMsgToVaa(message *nodev1.GovernanceMessage, currentSetIndex uint32, time
 		v, err = wormchainMigrateContract(payload.WormchainMigrateContract, timestamp, currentSetIndex, message.Nonce, message.Sequence)
 	case *nodev1.GovernanceMessage_WormchainWasmInstantiateAllowlist:
 		v, err = wormchainWasmInstantiateAllowlist(payload.WormchainWasmInstantiateAllowlist, timestamp, currentSetIndex, message.Nonce, message.Sequence)
-	case *nodev1.GovernanceMessage_WormchainIbcComposabilityMwSetContract:
-		v, err = wormchainIbcComposabilityMwSetContract(payload.WormchainIbcComposabilityMwSetContract, timestamp, currentSetIndex, message.Nonce, message.Sequence)
+	case *nodev1.GovernanceMessage_GatewayIbcComposabilityMwSetContract:
+		v, err = gatewayIbcComposabilityMwSetContract(payload.GatewayIbcComposabilityMwSetContract, timestamp, currentSetIndex, message.Nonce, message.Sequence)
+	case *nodev1.GovernanceMessage_GatewaySetTokenfactoryPfmDefaultParams:
+		v = gatewaySetTokenfactoryPfmDefaultParams(timestamp, currentSetIndex, message.Nonce, message.Sequence)
 	case *nodev1.GovernanceMessage_CircleIntegrationUpdateWormholeFinality:
 		v, err = circleIntegrationUpdateWormholeFinality(payload.CircleIntegrationUpdateWormholeFinality, timestamp, currentSetIndex, message.Nonce, message.Sequence)
 	case *nodev1.GovernanceMessage_CircleIntegrationRegisterEmitterAndDomain:

proto/node/v1/node.proto

@@ -93,7 +93,10 @@ message GovernanceMessage {
     WormchainInstantiateContract wormchain_instantiate_contract = 15;
     WormchainMigrateContract wormchain_migrate_contract = 16;
     WormchainWasmInstantiateAllowlist wormchain_wasm_instantiate_allowlist = 23;
-    WormchainIbcComposabilityMwSetContract wormchain_ibc_composability_mw_set_contract = 24;
+
+    // Gateway
+    GatewayIbcComposabilityMwSetContract gateway_ibc_composability_mw_set_contract = 24;
+    GatewaySetTokenfactoryPfmDefaultParams gateway_set_tokenfactory_pfm_default_params = 25;
 
     // Global Accountant
     AccountantModifyBalance accountant_modify_balance = 17;
@@ -243,11 +246,13 @@ message WormchainWasmInstantiateAllowlist {
   WormchainWasmInstantiateAllowlistAction action = 3;
 }
 
-message WormchainIbcComposabilityMwSetContract {
+message GatewayIbcComposabilityMwSetContract {
     // The address of the contract that is set in the ibc composability middleware.
     string contract = 1;
 }
 
+message GatewaySetTokenfactoryPfmDefaultParams {}
+
 message CircleIntegrationUpdateWormholeFinality {
   uint32 finality = 1;
   uint32 target_chain_id = 2;

sdk/vaa/payloads.go

@@ -74,7 +74,8 @@ var (
 	ActionDeleteWasmInstantiateAllowlist GovernanceAction = 5
 
 	// Gateway governance actions
-	ActionSetIbcComposabilityMwContract GovernanceAction = 1
+	ActionSetIbcComposabilityMwContract   GovernanceAction = 1
+	ActionSetTokenfactoryPfmDefaultParams GovernanceAction = 2
 
 	// Accountant goverance actions
 	ActionModifyBalance GovernanceAction = 1
@@ -160,8 +161,8 @@ type (
 		CodeId       uint64
 	}
 
-	// BodyWormchainIbcComposabilityMwContract is a governance message to set a specific contract (i.e. IBC Translator) for the ibc composability middleware to use
-	BodyWormchainIbcComposabilityMwContract struct {
+	// BodyGatewayIbcComposabilityMwContract is a governance message to set a specific contract (i.e. IBC Translator) for the ibc composability middleware to use
+	BodyGatewayIbcComposabilityMwContract struct {
 		ContractAddr [32]byte
 	}
 
@@ -305,13 +306,13 @@ func (r *BodyWormchainWasmAllowlistInstantiate) Deserialize(bz []byte) {
 	r.CodeId = codeId
 }
 
-func (r BodyWormchainIbcComposabilityMwContract) Serialize() []byte {
+func (r BodyGatewayIbcComposabilityMwContract) Serialize() []byte {
 	payload := &bytes.Buffer{}
 	payload.Write(r.ContractAddr[:])
 	return serializeBridgeGovernanceVaa(GatewayModuleStr, ActionSetIbcComposabilityMwContract, ChainIDWormchain, payload.Bytes())
 }
 
-func (r *BodyWormchainIbcComposabilityMwContract) Deserialize(bz []byte) {
+func (r *BodyGatewayIbcComposabilityMwContract) Deserialize(bz []byte) {
 	if len(bz) != 32 {
 		panic("incorrect payload length")
 	}
@@ -357,6 +358,10 @@ func (r BodyWormholeRelayerSetDefaultDeliveryProvider) Serialize() []byte {
 	return serializeBridgeGovernanceVaa(WormholeRelayerModuleStr, WormholeRelayerSetDefaultDeliveryProvider, r.ChainID, payload.Bytes())
 }
 
+func EmptyPayloadVaa(module string, actionId GovernanceAction, chainId ChainID) []byte {
+	return serializeBridgeGovernanceVaa(module, actionId, chainId, []byte{})
+}
+
 func serializeBridgeGovernanceVaa(module string, actionId GovernanceAction, chainId ChainID, payload []byte) []byte {
 	buf := LeftPadBytes(module, 32)
 	// Write action ID

sdk/vaa/payloads_test.go

@@ -210,19 +210,19 @@ func TestBodyWormholeRelayerSetDefaultDeliveryProviderSerialize(t *testing.T) {
 	assert.Equal(t, expected, hex.EncodeToString(bodyWormholeRelayerSetDefaultDeliveryProvider.Serialize()))
 }
 
-func TestBodyWormchainIbcComposabilityMwContractSerialize(t *testing.T) {
+func TestBodyGatewayIbcComposabilityMwContractSerialize(t *testing.T) {
 	expected := "00000000000000000000000000000000000000476174657761794d6f64756c65010c200102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20"
-	bodyWormchainIbcComposabilityMwContract := BodyWormchainIbcComposabilityMwContract{
+	bodyGatewayIbcComposabilityMwContract := BodyGatewayIbcComposabilityMwContract{
 		ContractAddr: dummyBytes,
 	}
-	assert.Equal(t, expected, hex.EncodeToString(bodyWormchainIbcComposabilityMwContract.Serialize()))
+	assert.Equal(t, expected, hex.EncodeToString(bodyGatewayIbcComposabilityMwContract.Serialize()))
 }
 
-func TestBodyWormchainIbcComposabilityMwContractDeserialize(t *testing.T) {
-	expected := BodyWormchainIbcComposabilityMwContract{
+func TestBodyGatewayIbcComposabilityMwContractDeserialize(t *testing.T) {
+	expected := BodyGatewayIbcComposabilityMwContract{
 		ContractAddr: dummyBytes,
 	}
-	var payloadBody BodyWormchainIbcComposabilityMwContract
+	var payloadBody BodyGatewayIbcComposabilityMwContract
 	payloadBody.Deserialize(dummyBytes[:])
 	assert.Equal(t, expected, payloadBody)
 }

wormchain/app/app.go

@@ -402,6 +402,7 @@ func New(
 	)
 
 	app.WireICS20PreWasmKeeper(&app.WormholeKeeper)
+	app.WormholeKeeper.SetPfmKeeper(*app.PacketForwardKeeper)
 
 	// register the proposal types
 	govRouter := govtypes.NewRouter()
@@ -433,6 +434,7 @@ func New(
 		app.DistrKeeper,
 		tokenFactoryCapabilities,
 	)
+	app.WormholeKeeper.SetTokenfactoryKeeper(app.TokenFactoryKeeper)
 
 	// The last arguments can contain custom message handlers, and custom query handlers,
 	// if we want to allow any custom callbacks

wormchain/proto/wormhole/tx.proto

@@ -23,13 +23,15 @@ service Msg {
   rpc AddWasmInstantiateAllowlist(MsgAddWasmInstantiateAllowlist) returns (MsgWasmInstantiateAllowlistResponse);
   rpc DeleteWasmInstantiateAllowlist(MsgDeleteWasmInstantiateAllowlist) returns (MsgWasmInstantiateAllowlistResponse);
 
-  rpc SetIbcComposabilityMwContract(MsgSetIbcComposabilityMwContract) returns (MsgSetIbcComposabilityMwContractResponse);
-
   rpc MigrateContract(MsgMigrateContract)
     returns (MsgMigrateContractResponse);
+
+  rpc ExecuteGatewayGovernanceVaa(MsgExecuteGatewayGovernanceVaa) returns (EmptyResponse);
 // this line is used by starport scaffolding # proto/tx/rpc
 }
 
+message EmptyResponse {}
+
 message MsgCreateAllowlistEntryRequest {
   // signer should be a guardian validator in a current set or future set.
   string signer = 1;
@@ -124,18 +126,7 @@ message MsgDeleteWasmInstantiateAllowlist {
     bytes vaa = 4;
 }
 
-message MsgWasmInstantiateAllowlistResponse {}
-
-message MsgSetIbcComposabilityMwContract {
-    // signer should be a guardian validator in a current set or future set.
-    string signer = 1;
-    // the contract address to set
-    string address = 2;
-    // vaa is the SetIbcComposabilityMwContract governance message
-    bytes vaa = 3;
-}
-
-message MsgSetIbcComposabilityMwContractResponse {}
+message MsgWasmInstantiateAllowlistResponse {} 
 
 // MsgMigrateContract runs a code upgrade/ downgrade for a smart contract
 message MsgMigrateContract {
@@ -159,3 +150,10 @@ message MsgMigrateContractResponse {
   bytes data = 1;
 }
 // this line is used by starport scaffolding # proto/tx/message
+
+message MsgExecuteGatewayGovernanceVaa {
+  // Sender is the actor that signs the messages
+  string signer = 1;
+  // vaa must be governance msg with valid module, action, and payload
+  bytes vaa = 2;
+}

wormchain/x/wormhole/client/cli/tx.go

@@ -29,7 +29,7 @@ func GetTxCmd() *cobra.Command {
 	cmd.AddCommand(CmdDeleteAllowedAddress())
 	cmd.AddCommand(CmdAddWasmInstantiateAllowlist())
 	cmd.AddCommand(CmdDeleteWasmInstantiateAllowlist())
-	cmd.AddCommand(CmdSetIbcComposabilityMwContract())
+	cmd.AddCommand(CmdExecuteGatewayGovernanceVaa())
 	// this line is used by starport scaffolding # 1
 
 	return cmd

wormchain/x/wormhole/client/cli/tx_set_ibc_composability_mw_contract.go → wormchain/x/wormhole/client/cli/tx_execute_gateway_governance_vaa.go

@@ -13,28 +13,26 @@ import (
 
 var _ = strconv.Itoa(0)
 
-// CmdSetIbcComposabilityMwContract will set the contract that ibc composability middleware will use.
-func CmdSetIbcComposabilityMwContract() *cobra.Command {
+// CmdExecuteGatewayGovernanceVaa will submit and execute a governance VAA for wormhole Gateway.
+func CmdExecuteGatewayGovernanceVaa() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   "set-ibc-composability-mw-contract [bech32 contract addr] [vaa-hex]",
-		Short: "Sets the contract that ibc composability middleware will use",
-		Args:  cobra.ExactArgs(2),
+		Use:   "execute-gateway-governance-vaa [vaa-hex]",
+		Short: "Execute the provided Wormhole Gateway governance VAA",
+		Args:  cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			clientCtx, err := client.GetClientTxContext(cmd)
 			if err != nil {
 				return err
 			}
-			address := args[0]
 
-			vaaBz, err := hex.DecodeString(args[1])
+			vaaBz, err := hex.DecodeString(args[0])
 			if err != nil {
 				return err
 			}
 
-			msg := types.MsgSetIbcComposabilityMwContract{
-				Signer:  clientCtx.GetFromAddress().String(),
-				Address: address,
-				Vaa:     vaaBz,
+			msg := types.MsgExecuteGatewayGovernanceVaa{
+				Signer: clientCtx.GetFromAddress().String(),
+				Vaa:    vaaBz,
 			}
 
 			if err = msg.ValidateBasic(); err != nil {

wormchain/x/wormhole/handler.go

@@ -44,8 +44,8 @@ func NewHandler(k keeper.Keeper) sdk.Handler {
 		case *types.MsgDeleteAllowlistEntryRequest:
 			res, err := msgServer.DeleteAllowlistEntry(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
-		case *types.MsgSetIbcComposabilityMwContract:
-			res, err := msgServer.SetIbcComposabilityMwContract(sdk.WrapSDKContext(ctx), msg)
+		case *types.MsgExecuteGatewayGovernanceVaa:
+			res, err := msgServer.ExecuteGatewayGovernanceVaa(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
 			// this line is used by starport scaffolding # 1
 		default:

wormchain/x/wormhole/keeper/keeper.go

@@ -7,6 +7,8 @@ import (
 
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	pfmkeeper "github.com/strangelove-ventures/packet-forward-middleware/v4/router/keeper"
+	tokenfactorykeeper "github.com/wormhole-foundation/wormchain/x/tokenfactory/keeper"
 	"github.com/wormhole-foundation/wormchain/x/wormhole/types"
 )
 
@@ -16,10 +18,15 @@ type (
 		storeKey sdk.StoreKey
 		memKey   sdk.StoreKey
 
-		accountKeeper types.AccountKeeper
-		bankKeeper    types.BankKeeper
-		wasmdKeeper   types.WasmdKeeper
-		setWasmd      bool
+		accountKeeper      types.AccountKeeper
+		bankKeeper         types.BankKeeper
+		wasmdKeeper        types.WasmdKeeper
+		tokenfactoryKeeper tokenfactorykeeper.Keeper
+		pfmKeeper          pfmkeeper.Keeper
+
+		setWasmd        bool
+		setTokenfactory bool
+		setPfm          bool
 	}
 )
 
@@ -50,6 +57,18 @@ func (k *Keeper) SetWasmdKeeper(keeper types.WasmdKeeper) {
 	k.setWasmd = true
 }
 
+// Necessary because x/staking relies on x/wormhole and x/tokenfactory relies on x/staking (transitively)
+func (k *Keeper) SetTokenfactoryKeeper(keeper tokenfactorykeeper.Keeper) {
+	k.tokenfactoryKeeper = keeper
+	k.setTokenfactory = true
+}
+
+// Necesesary because x/staking relies on x/wormhole and PFM relies on x/staking (transitively)
+func (k *Keeper) SetPfmKeeper(keeper pfmkeeper.Keeper) {
+	k.pfmKeeper = keeper
+	k.setPfm = true
+}
+
 func (k Keeper) Logger(ctx sdk.Context) log.Logger {
 	return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName))
 }

wormchain/x/wormhole/keeper/msg_server_execute_gateway_governance_vaa.go

@@ -0,0 +1,86 @@
+package keeper
+
+import (
+	"context"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	pfmtypes "github.com/strangelove-ventures/packet-forward-middleware/v4/router/types"
+	tokenfactorytypes "github.com/wormhole-foundation/wormchain/x/tokenfactory/types"
+	"github.com/wormhole-foundation/wormchain/x/wormhole/types"
+	"github.com/wormhole-foundation/wormhole/sdk/vaa"
+)
+
+func (k msgServer) ExecuteGatewayGovernanceVaa(
+	goCtx context.Context,
+	msg *types.MsgExecuteGatewayGovernanceVaa,
+) (*types.EmptyResponse, error) {
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	// Validate signer
+	_, err := sdk.AccAddressFromBech32(msg.Signer)
+	if err != nil {
+		return nil, sdkerrors.Wrap(err, "signer")
+	}
+	ctx.EventManager().EmitEvent(sdk.NewEvent(
+		sdk.EventTypeMessage,
+		sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName),
+		sdk.NewAttribute(sdk.AttributeKeySender, msg.Signer),
+	))
+
+	// Parse VAA
+	v, err := ParseVAA(msg.Vaa)
+	if err != nil {
+		return nil, err
+	}
+
+	// Verify VAA
+	action, payload, err := k.VerifyGovernanceVAA(ctx, v, vaa.GatewayModule)
+	if err != nil {
+		return nil, err
+	}
+
+	// Execute action
+	switch vaa.GovernanceAction(action) {
+	case vaa.ActionSetIbcComposabilityMwContract:
+		return k.setIbcComposabilityMwContract(ctx, payload)
+	case vaa.ActionSetTokenfactoryPfmDefaultParams:
+		return k.setTokenfactoryPfmDefaultParams(ctx)
+	default:
+		return nil, types.ErrUnknownGovernanceAction
+	}
+}
+
+func (k msgServer) setIbcComposabilityMwContract(
+	ctx sdk.Context,
+	payload []byte,
+) (*types.EmptyResponse, error) {
+	// validate the contractAddress in the VAA payload match the ones in the message
+	var payloadBody vaa.BodyGatewayIbcComposabilityMwContract
+	payloadBody.Deserialize(payload)
+
+	// convert bytes to bech32 address
+	contractAddr, err := sdk.Bech32ifyAddressBytes(
+		sdk.GetConfig().GetBech32AccountAddrPrefix(),
+		payloadBody.ContractAddr[:],
+	)
+	if err != nil {
+		return nil, types.ErrInvalidIbcComposabilityMwContractAddr
+	}
+
+	newContract := types.IbcComposabilityMwContract{
+		ContractAddress: contractAddr,
+	}
+
+	k.StoreIbcComposabilityMwContract(ctx, newContract)
+
+	return &types.EmptyResponse{}, nil
+}
+
+func (k msgServer) setTokenfactoryPfmDefaultParams(ctx sdk.Context) (*types.EmptyResponse, error) {
+	// Set the default params for both tokenfactory and PFM
+	k.tokenfactoryKeeper.SetParams(ctx, tokenfactorytypes.DefaultParams())
+	k.pfmKeeper.SetParams(ctx, pfmtypes.DefaultParams())
+
+	return &types.EmptyResponse{}, nil
+}

wormchain/x/wormhole/keeper/msg_server_ibc_composability_mw.go

@@ -1,64 +0,0 @@
-package keeper
-
-import (
-	"bytes"
-	"context"
-
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
-	"github.com/wormhole-foundation/wormchain/x/wormhole/types"
-	"github.com/wormhole-foundation/wormhole/sdk/vaa"
-)
-
-func (k msgServer) SetIbcComposabilityMwContract(goCtx context.Context, msg *types.MsgSetIbcComposabilityMwContract) (*types.MsgSetIbcComposabilityMwContractResponse, error) {
-	ctx := sdk.UnwrapSDKContext(goCtx)
-
-	// Parse VAA
-	v, err := ParseVAA(msg.Vaa)
-	if err != nil {
-		return nil, err
-	}
-
-	// Verify VAA
-	action, payload, err := k.VerifyGovernanceVAA(ctx, v, vaa.GatewayModule)
-	if err != nil {
-		return nil, err
-	}
-
-	// Ensure the governance action is correct
-	if vaa.GovernanceAction(action) != vaa.ActionSetIbcComposabilityMwContract {
-		return nil, types.ErrUnknownGovernanceAction
-	}
-
-	// Validate signer
-	_, err = sdk.AccAddressFromBech32(msg.Signer)
-	if err != nil {
-		return nil, sdkerrors.Wrap(err, "signer")
-	}
-	ctx.EventManager().EmitEvent(sdk.NewEvent(
-		sdk.EventTypeMessage,
-		sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName),
-		sdk.NewAttribute(sdk.AttributeKeySender, msg.Signer),
-	))
-
-	// verify the cosmos address is correct
-	addrBytes, err := sdk.AccAddressFromBech32(msg.Address)
-	if err != nil {
-		return nil, sdkerrors.Wrap(err, "ibc composability mw contract")
-	}
-
-	// validate the contractAddress in the VAA payload match the ones in the message
-	var payloadBody vaa.BodyWormchainIbcComposabilityMwContract
-	payloadBody.Deserialize(payload)
-	if !bytes.Equal(payloadBody.ContractAddr[:], addrBytes) {
-		return nil, types.ErrInvalidIbcComposabilityMwContractAddr
-	}
-
-	newContract := types.IbcComposabilityMwContract{
-		ContractAddress: msg.Address,
-	}
-
-	k.StoreIbcComposabilityMwContract(ctx, newContract)
-
-	return &types.MsgSetIbcComposabilityMwContractResponse{}, nil
-}

wormchain/x/wormhole/types/codec.go

@@ -18,6 +18,7 @@ func RegisterCodec(cdc *codec.LegacyAmino) {
 	cdc.RegisterConcrete(&MsgDeleteAllowlistEntryRequest{}, "wormhole/DeleteAllowlistEntryRequest", nil)
 	cdc.RegisterConcrete(&MsgAddWasmInstantiateAllowlist{}, "wormhole/AddWasmInstantiateAllowlist", nil)
 	cdc.RegisterConcrete(&MsgDeleteWasmInstantiateAllowlist{}, "wormhole/DeleteWasmInstantiateAllowlist", nil)
+	cdc.RegisterConcrete(&MsgExecuteGatewayGovernanceVaa{}, "wormhole/ExecuteGatewayGovernanceVaa", nil)
 	// this line is used by starport scaffolding # 2
 }
 
@@ -29,6 +30,7 @@ func RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
 		&MsgMigrateContract{},
 		&MsgCreateAllowlistEntryRequest{},
 		&MsgDeleteAllowlistEntryRequest{},
+		&MsgExecuteGatewayGovernanceVaa{},
 	)
 	registry.RegisterImplementations((*gov.Content)(nil),
 		&GovernanceWormholeMessageProposal{},

wormchain/x/wormhole/types/message_execute_gateway_governance_vaa.go

@@ -0,0 +1,38 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+var _ sdk.Msg = &MsgExecuteGatewayGovernanceVaa{}
+
+func (msg *MsgExecuteGatewayGovernanceVaa) Route() string {
+	return RouterKey
+}
+
+func (msg *MsgExecuteGatewayGovernanceVaa) Type() string {
+	return "MsgExecuteGatewayGovernanceVaa"
+}
+
+func (msg *MsgExecuteGatewayGovernanceVaa) GetSigners() []sdk.AccAddress {
+	signer, err := sdk.AccAddressFromBech32(msg.Signer)
+	if err != nil {
+		panic(err)
+	}
+	return []sdk.AccAddress{signer}
+}
+
+func (msg *MsgExecuteGatewayGovernanceVaa) GetSignBytes() []byte {
+	bz := ModuleCdc.MustMarshalJSON(msg)
+	return sdk.MustSortJSON(bz)
+}
+
+func (msg *MsgExecuteGatewayGovernanceVaa) ValidateBasic() error {
+	_, err := sdk.AccAddressFromBech32(msg.Signer)
+	if err != nil {
+		return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid signer address (%s)", err)
+	}
+
+	return nil
+}

wormchain/x/wormhole/types/message_ibc_composability_mw.go

@@ -1,43 +0,0 @@
-package types
-
-import (
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
-)
-
-var _ sdk.Msg = &MsgSetIbcComposabilityMwContract{}
-
-func (msg *MsgSetIbcComposabilityMwContract) Route() string {
-	return RouterKey
-}
-
-func (msg *MsgSetIbcComposabilityMwContract) Type() string {
-	return "MsgSetIbcComposabilityMwContract"
-}
-
-func (msg *MsgSetIbcComposabilityMwContract) GetSigners() []sdk.AccAddress {
-	signer, err := sdk.AccAddressFromBech32(msg.Signer)
-	if err != nil {
-		panic(err)
-	}
-	return []sdk.AccAddress{signer}
-}
-
-func (msg *MsgSetIbcComposabilityMwContract) GetSignBytes() []byte {
-	bz := ModuleCdc.MustMarshalJSON(msg)
-	return sdk.MustSortJSON(bz)
-}
-
-func (msg *MsgSetIbcComposabilityMwContract) ValidateBasic() error {
-	_, err := sdk.AccAddressFromBech32(msg.Signer)
-	if err != nil {
-		return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid signer address (%s)", err)
-	}
-
-	_, err = sdk.AccAddressFromBech32(msg.Address)
-	if err != nil {
-		return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid contract address (%s)", err)
-	}
-
-	return nil
-}