diff --git a/proto/vaas/provider/v1/genesis.proto b/proto/vaas/provider/v1/genesis.proto
index 9fe86ff..0c5f8d6 100644
--- a/proto/vaas/provider/v1/genesis.proto
+++ b/proto/vaas/provider/v1/genesis.proto
@@ -68,7 +68,7 @@ message ConsumerState {
   // the phase of the consumer chain
   ConsumerPhase phase = 8;
   // OwnerAddress is the bech32 address that authorises owner-only operations
-  // (UpdateConsumer, RemoveConsumer, key assignment, etc.) on the consumer.
+  // (UpdateConsumer, key assignment, etc.) on the consumer.
   // Always non-empty for any existing consumer record; set at REGISTERED.
   string owner_address = 9;
   // Metadata is the owner-supplied descriptor (name/description/repo).
diff --git a/proto/vaas/provider/v1/provider.proto b/proto/vaas/provider/v1/provider.proto
index 0abd866..4c008c8 100644
--- a/proto/vaas/provider/v1/provider.proto
+++ b/proto/vaas/provider/v1/provider.proto
@@ -206,6 +206,12 @@ enum ConsumerPhase {
 message InfractionParameters {
   SlashJailParameters double_sign = 1;
   SlashJailParameters downtime = 2;
+  // downtime_grace_period is the duration after a consumer chain launches
+  // during which downtime slashing is suppressed. This gives validators time
+  // to spin up their consumer chain nodes without being penalized for early
+  // downtime. Set to 0 to disable the grace period.
+  google.protobuf.Duration downtime_grace_period = 3
+      [ (gogoproto.nullable) = false, (gogoproto.stdduration) = true ];
 }
 
 //
diff --git a/proto/vaas/provider/v1/tx.proto b/proto/vaas/provider/v1/tx.proto
index 2a8f3c3..f449bc1 100644
--- a/proto/vaas/provider/v1/tx.proto
+++ b/proto/vaas/provider/v1/tx.proto
@@ -104,13 +104,14 @@ message MsgUpdateParamsResponse {}
 
 // MsgRemoveConsumer defines the message used to remove (and stop) a consumer chain.
 // If it passes, all the consumer chain's state is eventually removed from the provider chain.
+// Only the governance authority can remove a consumer chain.
 message MsgRemoveConsumer {
-  option (cosmos.msg.v1.signer) = "owner";
+  option (cosmos.msg.v1.signer) = "authority";
 
   // the consumer id of the consumer chain to be stopped
   uint64 consumer_id = 1;
-  // the address of the owner of the consumer chain to be stopped
-  string owner = 2 [(cosmos_proto.scalar) = "cosmos.AddressString"];
+  // authority is the address of the governance account.
+  string authority = 2 [(cosmos_proto.scalar) = "cosmos.AddressString"];
 }
 
 // MsgRemoveConsumerResponse defines response type for MsgRemoveConsumer messages
diff --git a/x/vaas/provider/client/cli/tx.go b/x/vaas/provider/client/cli/tx.go
index d26bef7..7633401 100644
--- a/x/vaas/provider/client/cli/tx.go
+++ b/x/vaas/provider/client/cli/tx.go
@@ -256,8 +256,8 @@ where create_consumer.json has the following structure:
 }
 
 Note that both 'chain_id' and 'metadata' are mandatory;
-and 'initialization_parameters' is optional. 
-The parameters not provided are set to their zero value. 
+and 'initialization_parameters' is optional.
+The parameters not provided are set to their zero value.
 `, version.AppName)),
 		Args: cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
diff --git a/x/vaas/provider/keeper/consumer_equivocation.go b/x/vaas/provider/keeper/consumer_equivocation.go
index a9d65e1..3df3bb0 100644
--- a/x/vaas/provider/keeper/consumer_equivocation.go
+++ b/x/vaas/provider/keeper/consumer_equivocation.go
@@ -203,10 +203,11 @@ func (k Keeper) HandleConsumerEvidencePacket(ctx sdk.Context, consumerId uint64,
 
 // HandleConsumerDowntime slashes a validator that was offline on a consumer chain.
 // The provider verifies the downtime claim by checking:
-//  1. The infraction height is not older than the minimum evidence height for this consumer.
-//  2. The provider's IBC client for the consumer has a consensus state at the infraction height,
+//  1. The consumer chain is outside its downtime grace period (if configured).
+//  2. The infraction height is not older than the minimum evidence height for this consumer.
+//  3. The provider's IBC client for the consumer has a consensus state at the infraction height,
 //     proving the consumer chain actually reached that height.
-//  3. The validator was part of the consumer's validator set at the time of the infraction.
+//  4. The validator was part of the consumer's validator set at the time of the infraction.
 //
 // CONTRACT: A downtime infraction must never jail a validator.
 func (k Keeper) HandleConsumerDowntime(ctx sdk.Context, consumerId uint64, evidencePacket vaastypes.EvidencePacketData) error {
@@ -214,6 +215,32 @@ func (k Keeper) HandleConsumerDowntime(ctx sdk.Context, consumerId uint64, evide
 
 	providerAddr := k.GetProviderAddrFromConsumerAddr(ctx, consumerId, consumerAddr)
 
+	// Check that the consumer chain is outside its downtime grace period.
+	// During the grace period after launch, downtime evidence is suppressed to give
+	// validators time to spin up their consumer chain nodes.
+	infractionParams := k.GetInfractionParams(ctx)
+	if infractionParams.DowntimeGracePeriod > 0 {
+		initParams, err := k.GetConsumerInitializationParameters(ctx, consumerId)
+		if err != nil {
+			return errorsmod.Wrapf(
+				vaastypes.ErrInvalidConsumerState,
+				"cannot get initialization parameters for consumer chain %d: %s",
+				consumerId, err,
+			)
+		}
+		gracePeriodEnd := initParams.SpawnTime.Add(infractionParams.DowntimeGracePeriod)
+		if ctx.BlockTime().Before(gracePeriodEnd) {
+			return errorsmod.Wrapf(
+				vaastypes.ErrInvalidPacketData,
+				"consumer chain %d is still in downtime grace period (launched %s, grace ends %s, now %s)",
+				consumerId,
+				initParams.SpawnTime.UTC(),
+				gracePeriodEnd.UTC(),
+				ctx.BlockTime().UTC(),
+			)
+		}
+	}
+
 	// Verify the infraction height is not too old.
 	minHeight := k.GetEquivocationEvidenceMinHeight(ctx, consumerId)
 	if uint64(evidencePacket.InfractionHeight) < minHeight {
@@ -270,8 +297,6 @@ func (k Keeper) HandleConsumerDowntime(ctx sdk.Context, consumerId uint64, evide
 		)
 	}
 
-	infractionParams := k.GetInfractionParams(ctx)
-
 	if err := k.SlashValidator(ctx, providerAddr, infractionParams.Downtime, stakingtypes.Infraction_INFRACTION_DOWNTIME); err != nil {
 		return err
 	}
diff --git a/x/vaas/provider/keeper/consumer_equivocation_test.go b/x/vaas/provider/keeper/consumer_equivocation_test.go
index 5b1b945..97510ff 100644
--- a/x/vaas/provider/keeper/consumer_equivocation_test.go
+++ b/x/vaas/provider/keeper/consumer_equivocation_test.go
@@ -837,7 +837,9 @@ func TestHandleConsumerEvidencePacket(t *testing.T) {
 	providerKeeper.SetConsumerChainId(ctx, consumerId, "consumer-chain")
 	providerKeeper.SetConsumerClientId(ctx, consumerId, "07-tendermint-0")
 	providerKeeper.SetEquivocationEvidenceMinHeight(ctx, consumerId, 1)
-	providerKeeper.SetInfractionParams(ctx, types.DefaultInfractionParameters())
+	noGraceParams := types.DefaultInfractionParameters()
+	noGraceParams.DowntimeGracePeriod = 0
+	providerKeeper.SetInfractionParams(ctx, noGraceParams)
 
 	pubKey, _ := cryptocodec.FromCmtPubKeyInterface(tmtypes.NewMockPV().PrivKey.PubKey())
 	validator, err := stakingtypes.NewValidator(
@@ -909,6 +911,9 @@ func TestHandleConsumerDowntimeRejectsTooOldEvidence(t *testing.T) {
 	providerKeeper.SetConsumerPhase(ctx, consumerId, types.CONSUMER_PHASE_LAUNCHED)
 	providerKeeper.SetConsumerChainId(ctx, consumerId, "consumer-chain")
 	providerKeeper.SetEquivocationEvidenceMinHeight(ctx, consumerId, 200)
+	noGraceParams := types.DefaultInfractionParameters()
+	noGraceParams.DowntimeGracePeriod = 0
+	providerKeeper.SetInfractionParams(ctx, noGraceParams)
 
 	evidencePacket := vaastypes.NewEvidencePacketData(
 		sdk.ConsAddress([]byte{0x01, 0x02, 0x03}),
@@ -930,6 +935,9 @@ func TestHandleConsumerDowntimeRejectsNoClient(t *testing.T) {
 	providerKeeper.SetConsumerPhase(ctx, consumerId, types.CONSUMER_PHASE_LAUNCHED)
 	providerKeeper.SetConsumerChainId(ctx, consumerId, "consumer-chain")
 	providerKeeper.SetEquivocationEvidenceMinHeight(ctx, consumerId, 1)
+	noGraceParams := types.DefaultInfractionParameters()
+	noGraceParams.DowntimeGracePeriod = 0
+	providerKeeper.SetInfractionParams(ctx, noGraceParams)
 
 	evidencePacket := vaastypes.NewEvidencePacketData(
 		sdk.ConsAddress([]byte{0x01, 0x02, 0x03}),
@@ -952,6 +960,9 @@ func TestHandleConsumerDowntimeRejectsNoConsensusState(t *testing.T) {
 	providerKeeper.SetConsumerChainId(ctx, consumerId, "consumer-chain")
 	providerKeeper.SetConsumerClientId(ctx, consumerId, "07-tendermint-0")
 	providerKeeper.SetEquivocationEvidenceMinHeight(ctx, consumerId, 1)
+	noGraceParams := types.DefaultInfractionParameters()
+	noGraceParams.DowntimeGracePeriod = 0
+	providerKeeper.SetInfractionParams(ctx, noGraceParams)
 
 	evidencePacket := vaastypes.NewEvidencePacketData(
 		sdk.ConsAddress([]byte{0x01, 0x02, 0x03}),
@@ -981,6 +992,9 @@ func TestHandleConsumerDowntimeRejectsValidatorNotInSet(t *testing.T) {
 	providerKeeper.SetConsumerChainId(ctx, consumerId, "consumer-chain")
 	providerKeeper.SetConsumerClientId(ctx, consumerId, "07-tendermint-0")
 	providerKeeper.SetEquivocationEvidenceMinHeight(ctx, consumerId, 1)
+	noGraceParams := types.DefaultInfractionParameters()
+	noGraceParams.DowntimeGracePeriod = 0
+	providerKeeper.SetInfractionParams(ctx, noGraceParams)
 
 	// Use a validator that is NOT in the consumer's validator set
 	evidencePacket := vaastypes.NewEvidencePacketData(
@@ -1011,6 +1025,9 @@ func TestHandleConsumerDowntimeRejectsInfractionBeforeJoin(t *testing.T) {
 	providerKeeper.SetConsumerChainId(ctx, consumerId, "consumer-chain")
 	providerKeeper.SetConsumerClientId(ctx, consumerId, "07-tendermint-0")
 	providerKeeper.SetEquivocationEvidenceMinHeight(ctx, consumerId, 1)
+	noGraceParams := types.DefaultInfractionParameters()
+	noGraceParams.DowntimeGracePeriod = 0
+	providerKeeper.SetInfractionParams(ctx, noGraceParams)
 
 	pubKey, _ := cryptocodec.FromCmtPubKeyInterface(tmtypes.NewMockPV().PrivKey.PubKey())
 	validator, err := stakingtypes.NewValidator(
@@ -1099,3 +1116,136 @@ func TestEvidencePacketDataJSONRoundTrip(t *testing.T) {
 	require.Equal(t, packet.InfractionHeight, decoded.InfractionHeight)
 	require.Equal(t, packet.Infraction, decoded.Infraction)
 }
+
+func TestHandleConsumerDowntimeRejectsDuringGracePeriod(t *testing.T) {
+	keeperParams := testkeeper.NewInMemKeeperParams(t)
+	providerKeeper, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, keeperParams)
+	defer ctrl.Finish()
+
+	consumerId := uint64(0)
+	providerKeeper.SetConsumerPhase(ctx, consumerId, types.CONSUMER_PHASE_LAUNCHED)
+	providerKeeper.SetConsumerChainId(ctx, consumerId, "consumer-chain")
+
+	spawnTime := time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC)
+	gracePeriod := 24 * time.Hour
+	now := spawnTime.Add(12 * time.Hour) // still within grace period
+	ctx = ctx.WithBlockTime(now)
+
+	providerKeeper.SetConsumerInitializationParameters(ctx, consumerId, types.ConsumerInitializationParameters{
+		SpawnTime: spawnTime,
+	})
+
+	providerKeeper.SetInfractionParams(ctx, types.InfractionParameters{
+		DoubleSign: &types.SlashJailParameters{
+			SlashFraction: math.LegacyMustNewDecFromStr("0.05"),
+			JailDuration:  time.Duration(1<<63 - 1),
+			Tombstone:     true,
+		},
+		Downtime: &types.SlashJailParameters{
+			SlashFraction: math.LegacyMustNewDecFromStr("0.0005"),
+			JailDuration:  0,
+			Tombstone:     false,
+		},
+		DowntimeGracePeriod: gracePeriod,
+	})
+
+	evidencePacket := vaastypes.NewEvidencePacketData(
+		sdk.ConsAddress([]byte{0x01, 0x02, 0x03}),
+		100,
+		stakingtypes.Infraction_INFRACTION_DOWNTIME,
+	)
+
+	err := providerKeeper.HandleConsumerEvidencePacket(ctx, consumerId, evidencePacket)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "grace period")
+}
+
+func TestHandleConsumerDowntimePassesAfterGracePeriod(t *testing.T) {
+	keeperParams := testkeeper.NewInMemKeeperParams(t)
+	providerKeeper, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, keeperParams)
+	defer ctrl.Finish()
+
+	consumerId := uint64(0)
+	providerKeeper.SetConsumerPhase(ctx, consumerId, types.CONSUMER_PHASE_LAUNCHED)
+	providerKeeper.SetConsumerChainId(ctx, consumerId, "consumer-chain")
+
+	spawnTime := time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC)
+	gracePeriod := 24 * time.Hour
+	now := spawnTime.Add(48 * time.Hour) // past grace period
+	ctx = ctx.WithBlockTime(now)
+
+	providerKeeper.SetConsumerInitializationParameters(ctx, consumerId, types.ConsumerInitializationParameters{
+		SpawnTime: spawnTime,
+	})
+
+	providerKeeper.SetInfractionParams(ctx, types.InfractionParameters{
+		DoubleSign: &types.SlashJailParameters{
+			SlashFraction: math.LegacyMustNewDecFromStr("0.05"),
+			JailDuration:  time.Duration(1<<63 - 1),
+			Tombstone:     true,
+		},
+		Downtime: &types.SlashJailParameters{
+			SlashFraction: math.LegacyMustNewDecFromStr("0.0005"),
+			JailDuration:  0,
+			Tombstone:     false,
+		},
+		DowntimeGracePeriod: gracePeriod,
+	})
+
+	evidencePacket := vaastypes.NewEvidencePacketData(
+		sdk.ConsAddress([]byte{0x01, 0x02, 0x03}),
+		100,
+		stakingtypes.Infraction_INFRACTION_DOWNTIME,
+	)
+
+	// Grace period check passes; the next validation (too-old evidence) should
+	// fail because no min-height is set (defaults to 0).
+	err := providerKeeper.HandleConsumerEvidencePacket(ctx, consumerId, evidencePacket)
+	require.Error(t, err)
+	require.NotContains(t, err.Error(), "grace period")
+}
+
+func TestHandleConsumerDowntimeNoGracePeriodSkipsCheck(t *testing.T) {
+	keeperParams := testkeeper.NewInMemKeeperParams(t)
+	providerKeeper, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, keeperParams)
+	defer ctrl.Finish()
+
+	consumerId := uint64(0)
+	providerKeeper.SetConsumerPhase(ctx, consumerId, types.CONSUMER_PHASE_LAUNCHED)
+	providerKeeper.SetConsumerChainId(ctx, consumerId, "consumer-chain")
+
+	// spawn time is very recent but grace period is 0 (disabled)
+	spawnTime := time.Now()
+	ctx = ctx.WithBlockTime(spawnTime)
+
+	providerKeeper.SetConsumerInitializationParameters(ctx, consumerId, types.ConsumerInitializationParameters{
+		SpawnTime: spawnTime,
+	})
+
+	providerKeeper.SetInfractionParams(ctx, types.InfractionParameters{
+		DoubleSign: &types.SlashJailParameters{
+			SlashFraction: math.LegacyMustNewDecFromStr("0.05"),
+			JailDuration:  time.Duration(1<<63 - 1),
+			Tombstone:     true,
+		},
+		Downtime: &types.SlashJailParameters{
+			SlashFraction: math.LegacyMustNewDecFromStr("0.0005"),
+			JailDuration:  0,
+			Tombstone:     false,
+		},
+		DowntimeGracePeriod: 0, // grace period disabled
+	})
+
+	evidencePacket := vaastypes.NewEvidencePacketData(
+		sdk.ConsAddress([]byte{0x01, 0x02, 0x03}),
+		100,
+		stakingtypes.Infraction_INFRACTION_DOWNTIME,
+	)
+
+	// Grace period is 0, so the check is skipped; should fail on the next
+	// validation (no IBC client) rather than grace period.
+	err := providerKeeper.HandleConsumerEvidencePacket(ctx, consumerId, evidencePacket)
+	require.Error(t, err)
+	require.NotContains(t, err.Error(), "grace period")
+	require.Contains(t, err.Error(), "no IBC client")
+}
diff --git a/x/vaas/provider/keeper/msg_server.go b/x/vaas/provider/keeper/msg_server.go
index 69fadb7..e92f9ff 100644
--- a/x/vaas/provider/keeper/msg_server.go
+++ b/x/vaas/provider/keeper/msg_server.go
@@ -266,6 +266,20 @@ func (k msgServer) CreateConsumer(goCtx context.Context, msg *types.MsgCreateCon
 			"cannot set consumer initialization parameters: %s", err.Error())
 	}
 
+	// add init params event attributes for validator discovery
+	if !initializationParameters.SpawnTime.IsZero() {
+		eventAttributes = append(eventAttributes,
+			sdk.NewAttribute(types.AttributeConsumerSpawnTime, initializationParameters.SpawnTime.String()))
+	}
+	if len(initializationParameters.BinaryHash) > 0 {
+		eventAttributes = append(eventAttributes,
+			sdk.NewAttribute(types.AttributeConsumerBinaryHash, string(initializationParameters.BinaryHash)))
+	}
+	if len(initializationParameters.GenesisHash) > 0 {
+		eventAttributes = append(eventAttributes,
+			sdk.NewAttribute(types.AttributeConsumerGenesisHash, string(initializationParameters.GenesisHash)))
+	}
+
 	// Power shaping and infraction parameters removed - all validators validate all consumers
 	// with default provider parameters
 
@@ -274,10 +288,6 @@ func (k msgServer) CreateConsumer(goCtx context.Context, msg *types.MsgCreateCon
 			return &resp, errorsmod.Wrapf(vaastypes.ErrInvalidConsumerState,
 				"prepare consumer for launch, consumerId(%d), spawnTime(%s): %s", consumerId, spawnTime, err.Error())
 		}
-
-		// add SpawnTime event attribute
-		eventAttributes = append(eventAttributes,
-			sdk.NewAttribute(types.AttributeConsumerSpawnTime, initializationParameters.SpawnTime.String()))
 	}
 
 	// add Phase event attribute
@@ -339,6 +349,21 @@ func (k msgServer) UpdateConsumer(goCtx context.Context, msg *types.MsgUpdateCon
 		return &resp, errorsmod.Wrapf(vaastypes.ErrInvalidConsumerState, "cannot get consumer chain ID: %s", err.Error())
 	}
 
+	isLaunched := k.GetConsumerPhase(ctx, consumerId) == types.CONSUMER_PHASE_LAUNCHED
+
+	// When the chain is already launched, the owner can only update metadata and transfer ownership.
+	// Chain-id and initialization parameters are restricted to pre-launch phases.
+	if isLaunched {
+		if strings.TrimSpace(msg.NewChainId) != "" {
+			return &resp, errorsmod.Wrapf(types.ErrInvalidPhase,
+				"cannot update chain id of a launched chain")
+		}
+		if msg.InitializationParameters != nil {
+			return &resp, errorsmod.Wrapf(types.ErrInvalidPhase,
+				"cannot update initialization parameters of a launched chain")
+		}
+	}
+
 	// We only validate and use `NewChainId` if it is not empty (because `NewChainId` is an optional argument)
 	// or `NewChainId` is different from the current chain id of the consumer chain.
 	if strings.TrimSpace(msg.NewChainId) != "" && msg.NewChainId != chainId {
@@ -423,6 +448,15 @@ func (k msgServer) UpdateConsumer(goCtx context.Context, msg *types.MsgUpdateCon
 		eventAttributes = append(eventAttributes,
 			sdk.NewAttribute(types.AttributeConsumerSpawnTime, msg.InitializationParameters.SpawnTime.String()))
 
+		if len(msg.InitializationParameters.BinaryHash) > 0 {
+			eventAttributes = append(eventAttributes,
+				sdk.NewAttribute(types.AttributeConsumerBinaryHash, string(msg.InitializationParameters.BinaryHash)))
+		}
+		if len(msg.InitializationParameters.GenesisHash) > 0 {
+			eventAttributes = append(eventAttributes,
+				sdk.NewAttribute(types.AttributeConsumerGenesisHash, string(msg.InitializationParameters.GenesisHash)))
+		}
+
 		if err = k.Keeper.SetConsumerInitializationParameters(ctx, msg.ConsumerId, *msg.InitializationParameters); err != nil {
 			return &resp, errorsmod.Wrapf(types.ErrInvalidConsumerInitializationParameters,
 				"cannot set consumer initialization parameters: %s", err.Error())
@@ -469,27 +503,24 @@ func (k msgServer) UpdateConsumer(goCtx context.Context, msg *types.MsgUpdateCon
 	return &resp, nil
 }
 
-// RemoveConsumer defines an RPC handler method for MsgRemoveConsumer
+// RemoveConsumer defines an RPC handler method for MsgRemoveConsumer.
+// Only the governance authority can remove a consumer chain.
 func (k msgServer) RemoveConsumer(goCtx context.Context, msg *types.MsgRemoveConsumer) (*types.MsgRemoveConsumerResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
+	if k.GetAuthority() != msg.Authority {
+		return nil, errorsmod.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.authority, msg.Authority)
+	}
+
 	resp := types.MsgRemoveConsumerResponse{}
 
 	consumerId := msg.ConsumerId
-	ownerAddress, err := k.Keeper.GetConsumerOwnerAddress(ctx, consumerId)
-	if err != nil {
-		return &resp, errorsmod.Wrapf(types.ErrNoOwnerAddress, "cannot retrieve owner address %s", ownerAddress)
-	}
 
 	chainId, err := k.GetConsumerChainId(ctx, consumerId)
 	if err != nil {
 		return &resp, errorsmod.Wrapf(vaastypes.ErrInvalidConsumerState, "cannot get consumer chain ID: %s", err.Error())
 	}
 
-	if msg.Owner != ownerAddress {
-		return &resp, errorsmod.Wrapf(types.ErrUnauthorized, "expected owner address %s, got %s", ownerAddress, msg.Owner)
-	}
-
 	phase := k.Keeper.GetConsumerPhase(ctx, consumerId)
 	if phase != types.CONSUMER_PHASE_LAUNCHED {
 		return &resp, errorsmod.Wrapf(types.ErrInvalidPhase,
@@ -510,7 +541,7 @@ func (k msgServer) RemoveConsumer(goCtx context.Context, msg *types.MsgRemoveCon
 			sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName),
 			sdk.NewAttribute(types.AttributeConsumerId, strconv.FormatUint(consumerId, 10)),
 			sdk.NewAttribute(types.AttributeConsumerChainId, chainId),
-			sdk.NewAttribute(types.AttributeSubmitterAddress, msg.Owner),
+			sdk.NewAttribute(types.AttributeSubmitterAddress, msg.Authority),
 		),
 	)
 
diff --git a/x/vaas/provider/keeper/msg_server_test.go b/x/vaas/provider/keeper/msg_server_test.go
index b956966..82b3ec5 100644
--- a/x/vaas/provider/keeper/msg_server_test.go
+++ b/x/vaas/provider/keeper/msg_server_test.go
@@ -632,6 +632,253 @@ func TestUpdateParams_ReconcilesFeesPerBlockOverrides(t *testing.T) {
 	require.Equal(t, math.NewInt(2500), amtAbove)
 }
 
+func TestRemoveConsumerGovAuth(t *testing.T) {
+	providerKeeper, ctx, ctrl, mocks := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t))
+	defer ctrl.Finish()
+
+	msgServer := providerkeeper.NewMsgServerImpl(&providerKeeper)
+
+	// create a consumer chain and set it to LAUNCHED
+	createResp, err := msgServer.CreateConsumer(ctx,
+		&providertypes.MsgCreateConsumer{
+			Submitter: "submitter", ChainId: "chainId",
+			Metadata: providertypes.ConsumerMetadata{
+				Name:        "name",
+				Description: "description",
+			},
+			InitializationParameters: &providertypes.ConsumerInitializationParameters{},
+		})
+	require.NoError(t, err)
+	consumerId := createResp.ConsumerId
+
+	providerKeeper.SetConsumerPhase(ctx, consumerId, providertypes.CONSUMER_PHASE_LAUNCHED)
+
+	mocks.MockStakingKeeper.EXPECT().UnbondingTime(gomock.Any()).Return(time.Hour*24*7*3, nil).Times(1)
+
+	// non-authority should be rejected
+	_, err = msgServer.RemoveConsumer(ctx,
+		&providertypes.MsgRemoveConsumer{
+			Authority:  "cosmos1notthegovauth000000000000000000000000",
+			ConsumerId: consumerId,
+		})
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "invalid authority")
+
+	// correct authority succeeds
+	_, err = msgServer.RemoveConsumer(ctx,
+		&providertypes.MsgRemoveConsumer{
+			Authority:  providerKeeper.GetAuthority(),
+			ConsumerId: consumerId,
+		})
+	require.NoError(t, err)
+
+	// verify the chain is stopped
+	phase := providerKeeper.GetConsumerPhase(ctx, consumerId)
+	require.Equal(t, providertypes.CONSUMER_PHASE_STOPPED, phase)
+}
+
+func TestRemoveConsumerNonLaunchedRejected(t *testing.T) {
+	providerKeeper, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t))
+	defer ctrl.Finish()
+
+	msgServer := providerkeeper.NewMsgServerImpl(&providerKeeper)
+
+	// create a consumer chain (stays in REGISTERED phase)
+	createResp, err := msgServer.CreateConsumer(ctx,
+		&providertypes.MsgCreateConsumer{
+			Submitter: "submitter", ChainId: "chainId",
+			Metadata: providertypes.ConsumerMetadata{
+				Name:        "name",
+				Description: "description",
+			},
+			InitializationParameters: &providertypes.ConsumerInitializationParameters{},
+		})
+	require.NoError(t, err)
+
+	// gov authority cannot remove a non-launched chain
+	_, err = msgServer.RemoveConsumer(ctx,
+		&providertypes.MsgRemoveConsumer{
+			Authority:  providerKeeper.GetAuthority(),
+			ConsumerId: createResp.ConsumerId,
+		})
+	require.Error(t, err)
+	require.ErrorIs(t, err, providertypes.ErrInvalidPhase)
+}
+
+func TestUpdateConsumerLaunchedOnlyMetadata(t *testing.T) {
+	providerKeeper, ctx, ctrl, mocks := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t))
+	defer ctrl.Finish()
+
+	msgServer := providerkeeper.NewMsgServerImpl(&providerKeeper)
+
+	// create a consumer chain
+	createResp, err := msgServer.CreateConsumer(ctx,
+		&providertypes.MsgCreateConsumer{
+			Submitter: "submitter", ChainId: "chainId",
+			Metadata: providertypes.ConsumerMetadata{
+				Name:        "name",
+				Description: "description",
+			},
+			InitializationParameters: &providertypes.ConsumerInitializationParameters{},
+		})
+	require.NoError(t, err)
+	consumerId := createResp.ConsumerId
+
+	// set to LAUNCHED
+	providerKeeper.SetConsumerPhase(ctx, consumerId, providertypes.CONSUMER_PHASE_LAUNCHED)
+
+	mocks.MockAccountKeeper.EXPECT().AddressCodec().Return(address.NewBech32Codec("cosmos")).AnyTimes()
+
+	// metadata update should succeed
+	newMetadata := providertypes.ConsumerMetadata{
+		Name:        "new-name",
+		Description: "new-description",
+		Metadata:    "new-metadata",
+	}
+	_, err = msgServer.UpdateConsumer(ctx,
+		&providertypes.MsgUpdateConsumer{
+			Owner:      "submitter",
+			ConsumerId: consumerId,
+			Metadata:   &newMetadata,
+		})
+	require.NoError(t, err)
+	actualMetadata, err := providerKeeper.GetConsumerMetadata(ctx, consumerId)
+	require.NoError(t, err)
+	require.Equal(t, newMetadata, actualMetadata)
+
+	// chain-id update should fail
+	_, err = msgServer.UpdateConsumer(ctx,
+		&providertypes.MsgUpdateConsumer{
+			Owner:      "submitter",
+			ConsumerId: consumerId,
+			NewChainId: "newChainId",
+		})
+	require.Error(t, err)
+	require.ErrorIs(t, err, providertypes.ErrInvalidPhase)
+
+	// owner transfer should succeed on launched chain
+	newOwner := "cosmos1dkas8mu4kyhl5jrh4nzvm65qz588hy9qcz08la"
+	_, err = msgServer.UpdateConsumer(ctx,
+		&providertypes.MsgUpdateConsumer{
+			Owner:           "submitter",
+			ConsumerId:      consumerId,
+			NewOwnerAddress: newOwner,
+		})
+	require.NoError(t, err)
+	actualOwner, err := providerKeeper.GetConsumerOwnerAddress(ctx, consumerId)
+	require.NoError(t, err)
+	require.Equal(t, newOwner, actualOwner)
+
+	// initialization parameters update should fail (use new owner since ownership was transferred)
+	_, err = msgServer.UpdateConsumer(ctx,
+		&providertypes.MsgUpdateConsumer{
+			Owner:      newOwner,
+			ConsumerId: consumerId,
+			InitializationParameters: &providertypes.ConsumerInitializationParameters{
+				SpawnTime: time.Now().Add(24 * time.Hour),
+			},
+		})
+	require.Error(t, err)
+	require.ErrorIs(t, err, providertypes.ErrInvalidPhase)
+}
+
+func TestUpdateConsumerPreLaunchAllowsAll(t *testing.T) {
+	providerKeeper, ctx, ctrl, mocks := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t))
+	defer ctrl.Finish()
+
+	msgServer := providerkeeper.NewMsgServerImpl(&providerKeeper)
+
+	// create a consumer chain (REGISTERED phase)
+	createResp, err := msgServer.CreateConsumer(ctx,
+		&providertypes.MsgCreateConsumer{
+			Submitter: "submitter", ChainId: "chainId-1",
+			Metadata: providertypes.ConsumerMetadata{
+				Name:        "name",
+				Description: "description",
+			},
+		})
+	require.NoError(t, err)
+	consumerId := createResp.ConsumerId
+
+	mocks.MockAccountKeeper.EXPECT().AddressCodec().Return(address.NewBech32Codec("cosmos")).AnyTimes()
+
+	// all updates should succeed in pre-launch phase
+	_, err = msgServer.UpdateConsumer(ctx,
+		&providertypes.MsgUpdateConsumer{
+			Owner:           "submitter",
+			ConsumerId:      consumerId,
+			NewChainId:      "newChainId-1",
+			NewOwnerAddress: "cosmos1dkas8mu4kyhl5jrh4nzvm65qz588hy9qcz08la",
+			Metadata: &providertypes.ConsumerMetadata{
+				Name:        "new-name",
+				Description: "new-description",
+			},
+		})
+	require.NoError(t, err)
+
+	// verify chain id updated
+	chainId, err := providerKeeper.GetConsumerChainId(ctx, consumerId)
+	require.NoError(t, err)
+	require.Equal(t, "newChainId-1", chainId)
+
+	// verify owner updated
+	owner, err := providerKeeper.GetConsumerOwnerAddress(ctx, consumerId)
+	require.NoError(t, err)
+	require.Equal(t, "cosmos1dkas8mu4kyhl5jrh4nzvm65qz588hy9qcz08la", owner)
+}
+
+func TestCreateConsumerEventsIncludeInitParams(t *testing.T) {
+	providerKeeper, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t))
+	defer ctrl.Finish()
+
+	msgServer := providerkeeper.NewMsgServerImpl(&providerKeeper)
+
+	binaryHash := []byte("deadbeef")
+	genesisHash := []byte("cafebabe")
+	spawnTime := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
+
+	_, err := msgServer.CreateConsumer(ctx,
+		&providertypes.MsgCreateConsumer{
+			Submitter: "submitter",
+			ChainId:   "chainId",
+			Metadata: providertypes.ConsumerMetadata{
+				Name:        "name",
+				Description: "description",
+			},
+			InitializationParameters: &providertypes.ConsumerInitializationParameters{
+				BinaryHash:  binaryHash,
+				GenesisHash: genesisHash,
+				SpawnTime:   spawnTime,
+			},
+		})
+	require.NoError(t, err)
+
+	// verify the event has binary_hash, genesis_hash, and spawn_time attributes
+	var found bool
+	for _, ev := range ctx.EventManager().Events() {
+		if ev.Type != "create_consumer" {
+			continue
+		}
+		found = true
+		var sawBinaryHash, sawGenesisHash, sawSpawnTime bool
+		for _, attr := range ev.Attributes {
+			if attr.Key == "consumer_binary_hash" && attr.Value == string(binaryHash) {
+				sawBinaryHash = true
+			}
+			if attr.Key == "consumer_genesis_hash" && attr.Value == string(genesisHash) {
+				sawGenesisHash = true
+			}
+			if attr.Key == "consumer_spawn_time" {
+				sawSpawnTime = true
+			}
+		}
+		require.True(t, sawBinaryHash, "consumer_binary_hash attribute missing")
+		require.True(t, sawGenesisHash, "consumer_genesis_hash attribute missing")
+		require.True(t, sawSpawnTime, "consumer_spawn_time attribute missing")
+	}
+	require.True(t, found, "create_consumer event not emitted")
+}
+
 func TestCreateConsumer_PopulatesReverseLookup(t *testing.T) {
 	k, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t))
 	defer ctrl.Finish()
diff --git a/x/vaas/provider/types/events.go b/x/vaas/provider/types/events.go
index 03f600e..b5dae48 100644
--- a/x/vaas/provider/types/events.go
+++ b/x/vaas/provider/types/events.go
@@ -27,6 +27,9 @@ const (
 	AttributeConsumerOwner            = "consumer_owner"
 	AttributeConsumerSpawnTime        = "consumer_spawn_time"
 	AttributeConsumerPhase            = "consumer_phase"
+	AttributeConsumerBinaryHash       = "consumer_binary_hash"
+	AttributeConsumerGenesisHash      = "consumer_genesis_hash"
+	AttributeKeyAmount                = "amount"
 	AttributeDepositor                = "depositor"
 	AttributeRecipient                = "recipient"
 	AttributeAmount                   = "amount"
diff --git a/x/vaas/provider/types/genesis.pb.go b/x/vaas/provider/types/genesis.pb.go
index f2d2b7a..1b2b7e3 100644
--- a/x/vaas/provider/types/genesis.pb.go
+++ b/x/vaas/provider/types/genesis.pb.go
@@ -170,7 +170,7 @@ type ConsumerState struct {
 	// the phase of the consumer chain
 	Phase ConsumerPhase `protobuf:"varint,8,opt,name=phase,proto3,enum=vaas.provider.v1.ConsumerPhase" json:"phase,omitempty"`
 	// OwnerAddress is the bech32 address that authorises owner-only operations
-	// (UpdateConsumer, RemoveConsumer, key assignment, etc.) on the consumer.
+	// (UpdateConsumer, key assignment, etc.) on the consumer.
 	// Always non-empty for any existing consumer record; set at REGISTERED.
 	OwnerAddress string `protobuf:"bytes,9,opt,name=owner_address,json=ownerAddress,proto3" json:"owner_address,omitempty"`
 	// Metadata is the owner-supplied descriptor (name/description/repo).
diff --git a/x/vaas/provider/types/msg.go b/x/vaas/provider/types/msg.go
index 4ac0540..5e53e98 100644
--- a/x/vaas/provider/types/msg.go
+++ b/x/vaas/provider/types/msg.go
@@ -285,15 +285,18 @@ func (msg MsgUpdateConsumer) ValidateBasic() error {
 }
 
 // NewMsgRemoveConsumer creates a new MsgRemoveConsumer instance
-func NewMsgRemoveConsumer(owner string, consumerId uint64) (*MsgRemoveConsumer, error) {
+func NewMsgRemoveConsumer(authority string, consumerId uint64) (*MsgRemoveConsumer, error) {
 	return &MsgRemoveConsumer{
-		Owner:      owner,
+		Authority:  authority,
 		ConsumerId: consumerId,
 	}, nil
 }
 
 // ValidateBasic implements the sdk.HasValidateBasic interface.
 func (msg MsgRemoveConsumer) ValidateBasic() error {
+	if _, err := sdk.AccAddressFromBech32(msg.Authority); err != nil {
+		return errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, "invalid authority address: %s", err)
+	}
 	return nil
 }
 
diff --git a/x/vaas/provider/types/params.go b/x/vaas/provider/types/params.go
index 7dffec9..26818ea 100644
--- a/x/vaas/provider/types/params.go
+++ b/x/vaas/provider/types/params.go
@@ -44,6 +44,11 @@ const (
 	// DefaultDowntimeSlashFraction is the default slash fraction for downtime infractions on consumer chains (0.05%).
 	DefaultDowntimeSlashFraction = "0.0005"
 
+	// DefaultDowntimeGracePeriod is the default grace period after a consumer chain launches
+	// during which downtime slashing is suppressed. This gives validators time to spin up
+	// their consumer chain nodes without being penalized for early downtime.
+	DefaultDowntimeGracePeriod = 7 * 24 * time.Hour // 1 week
+
 	// DefaultMinDepositBlocks is the default minimum-deposit floor expressed
 	// as a multiplier of FeesPerBlock.Amount. 14400 blocks is roughly one day
 	// at a 6s block time, so the default floor is "one day's worth of fees."
@@ -95,6 +100,7 @@ func DefaultInfractionParameters() InfractionParameters {
 			SlashFraction: downtimeSlashFraction,
 			Tombstone:     false,
 		},
+		DowntimeGracePeriod: DefaultDowntimeGracePeriod,
 	}
 }
 
@@ -127,6 +133,9 @@ func (ip InfractionParameters) Validate() error {
 	if err := ip.Downtime.Validate(); err != nil {
 		return fmt.Errorf("downtime: %s", err)
 	}
+	if ip.DowntimeGracePeriod < 0 {
+		return fmt.Errorf("downtime_grace_period must not be negative")
+	}
 	return nil
 }
 
diff --git a/x/vaas/provider/types/params_test.go b/x/vaas/provider/types/params_test.go
index 6d7d1bb..9b905fd 100644
--- a/x/vaas/provider/types/params_test.go
+++ b/x/vaas/provider/types/params_test.go
@@ -34,3 +34,38 @@ func TestValidateParams(t *testing.T) {
 		}
 	}
 }
+
+func TestValidateInfractionParameters(t *testing.T) {
+	testCases := []struct {
+		name    string
+		params  types.InfractionParameters
+		expPass bool
+	}{
+		{"default infraction params", types.DefaultInfractionParameters(), true},
+		{"negative grace period", types.InfractionParameters{
+			DoubleSign:         types.DefaultInfractionParameters().DoubleSign,
+			Downtime:           types.DefaultInfractionParameters().Downtime,
+			DowntimeGracePeriod: -1 * time.Second,
+		}, false},
+		{"zero grace period (disabled)", types.InfractionParameters{
+			DoubleSign:         types.DefaultInfractionParameters().DoubleSign,
+			Downtime:           types.DefaultInfractionParameters().Downtime,
+			DowntimeGracePeriod: 0,
+		}, true},
+		{"nil double_sign", types.InfractionParameters{
+			Downtime: types.DefaultInfractionParameters().Downtime,
+		}, false},
+		{"nil downtime", types.InfractionParameters{
+			DoubleSign: types.DefaultInfractionParameters().DoubleSign,
+		}, false},
+	}
+
+	for _, tc := range testCases {
+		err := tc.params.Validate()
+		if tc.expPass {
+			require.Nil(t, err, "expected error to be nil for testcase: %s", tc.name)
+		} else {
+			require.NotNil(t, err, "expected error but got nil for testcase: %s", tc.name)
+		}
+	}
+}
diff --git a/x/vaas/provider/types/provider.pb.go b/x/vaas/provider/types/provider.pb.go
index 1aec7e0..cd7c623 100644
--- a/x/vaas/provider/types/provider.pb.go
+++ b/x/vaas/provider/types/provider.pb.go
@@ -820,6 +820,11 @@ func (m *ConsumerIds) GetIds() []uint64 {
 type InfractionParameters struct {
 	DoubleSign *SlashJailParameters `protobuf:"bytes,1,opt,name=double_sign,json=doubleSign,proto3" json:"double_sign,omitempty"`
 	Downtime   *SlashJailParameters `protobuf:"bytes,2,opt,name=downtime,proto3" json:"downtime,omitempty"`
+	// downtime_grace_period is the duration after a consumer chain launches
+	// during which downtime slashing is suppressed. This gives validators time
+	// to spin up their consumer chain nodes without being penalized for early
+	// downtime. Set to 0 to disable the grace period.
+	DowntimeGracePeriod time.Duration `protobuf:"bytes,3,opt,name=downtime_grace_period,json=downtimeGracePeriod,proto3,stdduration" json:"downtime_grace_period"`
 }
 
 func (m *InfractionParameters) Reset()         { *m = InfractionParameters{} }
@@ -869,6 +874,13 @@ func (m *InfractionParameters) GetDowntime() *SlashJailParameters {
 	return nil
 }
 
+func (m *InfractionParameters) GetDowntimeGracePeriod() time.Duration {
+	if m != nil {
+		return m.DowntimeGracePeriod
+	}
+	return 0
+}
+
 type SlashJailParameters struct {
 	SlashFraction cosmossdk_io_math.LegacyDec `protobuf:"bytes,1,opt,name=slash_fraction,json=slashFraction,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"slash_fraction"`
 	// for permanent jailing use 9223372036854775807 which is the largest value a
@@ -945,94 +957,96 @@ func init() {
 func init() { proto.RegisterFile("vaas/provider/v1/provider.proto", fileDescriptor_6404dd5d21545279) }
 
 var fileDescriptor_6404dd5d21545279 = []byte{
-	// 1388 bytes of a gzipped FileDescriptorProto
+	// 1414 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xcd, 0x6f, 0x1c, 0xc5,
 	0x12, 0xf7, 0x78, 0x37, 0x8e, 0xdd, 0x6b, 0xfb, 0x6d, 0x3a, 0x4e, 0xb2, 0x76, 0x92, 0xb5, 0xb3,
-	0x4f, 0x79, 0xb2, 0xf2, 0xc8, 0x0c, 0x0e, 0x12, 0x42, 0x70, 0x88, 0x6c, 0xef, 0x24, 0x5e, 0xec,
-	0x38, 0xab, 0xd9, 0x0d, 0x87, 0x08, 0x34, 0xea, 0x9d, 0xe9, 0xec, 0x76, 0x3c, 0xd3, 0x3d, 0x9a,
-	0xee, 0x5d, 0x67, 0x39, 0x73, 0xe0, 0x18, 0x6e, 0xdc, 0x00, 0x71, 0xe1, 0xc8, 0x01, 0x71, 0xe4,
-	0x1c, 0x6e, 0x11, 0x27, 0x84, 0x50, 0x40, 0xc9, 0x81, 0x7f, 0x03, 0xf5, 0xc7, 0x8c, 0xc7, 0x1f,
-	0x11, 0x8e, 0xb8, 0x8c, 0xba, 0x7f, 0x55, 0xbf, 0xea, 0xaa, 0xea, 0xea, 0xaa, 0x01, 0xcb, 0x23,
-	0x84, 0xb8, 0x93, 0xa4, 0x6c, 0x44, 0x42, 0x9c, 0x3a, 0xa3, 0xb5, 0x7c, 0x6d, 0x27, 0x29, 0x13,
-	0x0c, 0x56, 0xa5, 0x82, 0x9d, 0x83, 0xa3, 0xb5, 0xa5, 0x73, 0x28, 0x26, 0x94, 0x39, 0xea, 0xab,
-	0x95, 0x96, 0x16, 0x03, 0xc6, 0x63, 0xc6, 0x7d, 0xb5, 0x73, 0xf4, 0xc6, 0x88, 0x16, 0xfa, 0xac,
-	0xcf, 0x34, 0x2e, 0x57, 0x06, 0xfd, 0x9f, 0xd6, 0x71, 0xb0, 0xb4, 0x4a, 0x03, 0xec, 0x8c, 0xd6,
-	0x7a, 0x58, 0xa0, 0xb5, 0x1c, 0x30, 0x7a, 0xf5, 0x3e, 0x63, 0xfd, 0x08, 0x3b, 0x6a, 0xd7, 0x1b,
-	0x3e, 0x72, 0xc2, 0x61, 0x8a, 0x04, 0x61, 0xd4, 0xc8, 0x97, 0x8f, 0xca, 0x05, 0x89, 0x31, 0x17,
-	0x28, 0x4e, 0x32, 0x05, 0xd2, 0x0b, 0x9c, 0x80, 0xa5, 0xd8, 0x09, 0x22, 0x82, 0xa9, 0x90, 0x11,
-	0xea, 0x95, 0x51, 0x70, 0xa4, 0x42, 0x44, 0xfa, 0x03, 0xa1, 0x61, 0xee, 0x08, 0x4c, 0x43, 0x9c,
-	0xc6, 0x44, 0x2b, 0x1f, 0xec, 0x0c, 0x01, 0xaa, 0x8c, 0x8d, 0xd6, 0x9c, 0x7d, 0x92, 0x66, 0x6e,
-	0x5e, 0x29, 0x70, 0x82, 0x74, 0x9c, 0x08, 0xe6, 0xec, 0xe1, 0xb1, 0x49, 0x41, 0xe3, 0xab, 0x12,
-	0x98, 0x6a, 0xa3, 0x14, 0xc5, 0x1c, 0xbe, 0x07, 0x6a, 0x22, 0x1d, 0x72, 0x41, 0x68, 0xdf, 0x4f,
-	0x70, 0x4a, 0x58, 0xe8, 0x3f, 0x4a, 0x51, 0x20, 0x23, 0xaa, 0x59, 0x2b, 0xd6, 0xea, 0x8c, 0x77,
-	0x31, 0x93, 0xb7, 0x95, 0xf8, 0x8e, 0x91, 0xc2, 0x0e, 0x38, 0x2f, 0x0f, 0xf6, 0x65, 0x80, 0x6c,
-	0x28, 0x0c, 0xbb, 0x36, 0xb9, 0x62, 0xad, 0x56, 0x6e, 0x2d, 0xda, 0x3a, 0x0f, 0x76, 0x96, 0x07,
-	0xbb, 0x69, 0xf2, 0xb4, 0x31, 0xfd, 0xec, 0xc5, 0xf2, 0xc4, 0x97, 0x7f, 0x2c, 0x5b, 0xde, 0x39,
-	0xc9, 0xef, 0x6a, 0xba, 0x36, 0x0e, 0x57, 0x41, 0xb5, 0x17, 0xb1, 0x60, 0x8f, 0x4b, 0x73, 0x3e,
-	0x4e, 0x58, 0x30, 0xa8, 0x95, 0x56, 0xac, 0xd5, 0x92, 0x37, 0xaf, 0xf1, 0x36, 0x4e, 0x5d, 0x89,
-	0xc2, 0x16, 0xb8, 0x16, 0xa3, 0x27, 0x7e, 0x56, 0x07, 0x7e, 0xc0, 0x28, 0xc7, 0x94, 0x0f, 0xb9,
-	0x3f, 0x42, 0x11, 0x09, 0x91, 0x60, 0x29, 0xaf, 0x95, 0x15, 0xb5, 0x1e, 0xa3, 0x27, 0x6d, 0xa3,
-	0xb7, 0x99, 0xa9, 0x7d, 0x94, 0x6b, 0xc1, 0x00, 0x5c, 0x78, 0x84, 0xb1, 0x3e, 0x52, 0x9d, 0xe2,
-	0xa3, 0x98, 0x0d, 0xa9, 0xa8, 0x9d, 0x91, 0x09, 0xd8, 0x78, 0x5b, 0x3a, 0xfc, 0xdb, 0x8b, 0xe5,
-	0x0b, 0xba, 0x44, 0x78, 0xb8, 0x67, 0x13, 0xe6, 0xc4, 0x48, 0x0c, 0xec, 0x16, 0x15, 0xbf, 0xfc,
-	0x70, 0x13, 0x98, 0xfa, 0x6a, 0x51, 0xf1, 0xdd, 0x5f, 0xdf, 0xdf, 0xb0, 0x3c, 0x28, 0xcd, 0xb5,
-	0x71, 0xba, 0x21, 0x8d, 0xad, 0x2b, 0x5b, 0xf0, 0x2d, 0x00, 0x63, 0x42, 0xfd, 0x10, 0x27, 0x8c,
-	0x13, 0xa1, 0xcf, 0xe1, 0xb5, 0xa9, 0x15, 0x6b, 0xb5, 0xec, 0x55, 0x63, 0x42, 0x9b, 0x5a, 0xa0,
-	0x28, 0xbc, 0xf1, 0x7f, 0x50, 0x59, 0x0f, 0xc3, 0x14, 0x73, 0xbe, 0x43, 0xb8, 0x80, 0x57, 0xc0,
-	0x0c, 0xd2, 0x5b, 0xcc, 0x6b, 0xd6, 0x4a, 0x69, 0x75, 0xd6, 0x3b, 0x00, 0x1a, 0x1f, 0x83, 0xc5,
-	0x3c, 0x9a, 0x0e, 0x16, 0x9b, 0x03, 0x44, 0xfb, 0xb8, 0x8d, 0x82, 0x3d, 0x2c, 0x38, 0xbc, 0x0d,
-	0xca, 0x11, 0xe1, 0x42, 0xb1, 0x2a, 0xb7, 0xae, 0xdb, 0xea, 0xf5, 0x8c, 0xd6, 0xec, 0xd7, 0x31,
-	0x9a, 0x48, 0xa0, 0x8d, 0xb2, 0x0c, 0xd9, 0x53, 0xc4, 0xc6, 0x17, 0x16, 0xa8, 0x6d, 0xe3, 0xf1,
-	0x3a, 0xe7, 0xa4, 0x4f, 0x63, 0x4c, 0x85, 0x87, 0x93, 0x08, 0x05, 0x58, 0x2e, 0xe1, 0x7f, 0xc1,
-	0x5c, 0x7e, 0x03, 0xd2, 0x21, 0x55, 0x33, 0xb3, 0xde, 0x6c, 0x06, 0xca, 0x20, 0xe0, 0xfb, 0x00,
-	0x24, 0x29, 0x1e, 0xf9, 0x81, 0xbf, 0x87, 0xc7, 0xa6, 0x40, 0xae, 0xd8, 0x85, 0x3a, 0xd6, 0x15,
-	0x6a, 0xb7, 0x87, 0xbd, 0x88, 0x04, 0xdb, 0x78, 0xec, 0x4d, 0x4b, 0xfd, 0xcd, 0x6d, 0x3c, 0x86,
-	0x0b, 0xe0, 0x4c, 0xc2, 0xf6, 0x71, 0x6a, 0xaa, 0x40, 0x6f, 0x1a, 0x5f, 0x5b, 0xe0, 0x52, 0x1e,
-	0x80, 0xbc, 0xd2, 0x61, 0x8c, 0xd3, 0xf6, 0xb0, 0x27, 0x19, 0xcb, 0xa0, 0x12, 0x18, 0xc4, 0x27,
-	0xa1, 0x72, 0xa8, 0xec, 0x81, 0x0c, 0x6a, 0x85, 0xc7, 0x7d, 0x9e, 0x3c, 0xc1, 0xe7, 0xdb, 0x60,
-	0x36, 0xb7, 0x22, 0xbd, 0x2e, 0x9d, 0xc2, 0xeb, 0xfc, 0xdc, 0x6d, 0x3c, 0x6e, 0x7c, 0x56, 0x74,
-	0x71, 0x63, 0x9c, 0x39, 0xa9, 0x8c, 0x9f, 0xc6, 0xc5, 0x5c, 0xa1, 0xe8, 0x62, 0x50, 0xb4, 0x72,
-	0x2c, 0x8e, 0xd2, 0xf1, 0x38, 0x1a, 0x3f, 0x59, 0x60, 0xa1, 0x78, 0x36, 0xef, 0xb2, 0x76, 0x3a,
-	0xa4, 0xf8, 0x9f, 0x7d, 0xb8, 0x0d, 0xa6, 0x13, 0xa9, 0xe9, 0x0b, 0x6e, 0xee, 0x6c, 0xe9, 0xd8,
-	0xa3, 0xee, 0x66, 0xcd, 0x4d, 0xbf, 0xea, 0xa7, 0xf2, 0x55, 0x9f, 0x55, 0xac, 0x2e, 0x87, 0x4d,
-	0x30, 0x7f, 0x28, 0x08, 0x6e, 0x92, 0x78, 0xd5, 0x3e, 0xda, 0xc1, 0xed, 0x42, 0xad, 0x7b, 0x73,
-	0xc5, 0x20, 0x79, 0xe3, 0x47, 0x0b, 0xc0, 0xe3, 0x8f, 0x56, 0x3e, 0xa7, 0x43, 0x4f, 0xbf, 0x58,
-	0x7d, 0xd5, 0xa4, 0xf0, 0xd8, 0x55, 0xaa, 0xf2, 0x2a, 0x9a, 0x2c, 0x54, 0x11, 0xfc, 0x00, 0x80,
-	0x44, 0x5d, 0xde, 0xa9, 0x6f, 0x78, 0x26, 0xc9, 0x96, 0x32, 0x7f, 0x8f, 0x19, 0xa1, 0xfe, 0x00,
-	0xcb, 0x56, 0x6d, 0x3a, 0x0d, 0x90, 0xd0, 0x96, 0x42, 0x1a, 0x21, 0xa8, 0x66, 0x89, 0xbf, 0x87,
-	0x05, 0x0a, 0x91, 0x40, 0x10, 0x82, 0x32, 0x45, 0x31, 0x36, 0x9d, 0x55, 0xad, 0xe1, 0x0a, 0xa8,
-	0x84, 0x98, 0x07, 0x29, 0x49, 0x54, 0xd3, 0x9d, 0x54, 0xa2, 0x22, 0x04, 0x97, 0xc0, 0x74, 0x6c,
-	0x2c, 0x28, 0x2f, 0x67, 0xbc, 0x7c, 0xdf, 0x78, 0x56, 0x02, 0x2b, 0xd9, 0x31, 0x2d, 0x4a, 0x04,
-	0x41, 0x11, 0xf9, 0x54, 0x35, 0x5a, 0xd5, 0xe0, 0xb1, 0xc0, 0x29, 0x87, 0x77, 0xc1, 0x3c, 0xd1,
-	0xb2, 0xcc, 0x5d, 0xcb, 0x5c, 0x28, 0xe9, 0x05, 0xb6, 0x1c, 0x46, 0xb6, 0x19, 0x41, 0xa3, 0x35,
-	0x5b, 0xbb, 0x6f, 0x5a, 0xc0, 0x9c, 0xe1, 0x69, 0x10, 0x5e, 0x03, 0xb3, 0x7d, 0x4c, 0x31, 0x27,
-	0xdc, 0x1f, 0x20, 0x3e, 0x30, 0x65, 0x59, 0x31, 0xd8, 0x16, 0xe2, 0x03, 0x99, 0x97, 0x1e, 0xa1,
-	0x28, 0x1d, 0x6b, 0x0d, 0x5d, 0x93, 0x40, 0x43, 0x4a, 0x61, 0x13, 0x00, 0x9e, 0xa0, 0x7d, 0xaa,
-	0x06, 0x87, 0xca, 0xdb, 0x69, 0x2b, 0x6b, 0x46, 0xf1, 0xa4, 0x04, 0xee, 0x82, 0xea, 0x90, 0xf6,
-	0x18, 0x0d, 0x0f, 0xe6, 0x96, 0xea, 0xd6, 0xa7, 0x9c, 0x3c, 0xff, 0xc9, 0xc9, 0x66, 0xee, 0xbc,
-	0x66, 0x98, 0x4d, 0xfd, 0xab, 0x61, 0x76, 0x13, 0xc0, 0x01, 0xe1, 0x82, 0xa5, 0x24, 0x40, 0x91,
-	0x8f, 0xa9, 0x48, 0x09, 0xe6, 0xb5, 0xb3, 0xaa, 0x52, 0xce, 0x1d, 0x48, 0x5c, 0x2d, 0x68, 0x2c,
-	0x83, 0x4a, 0x7e, 0x93, 0x21, 0x87, 0x55, 0x50, 0x22, 0xa1, 0xee, 0xf6, 0x65, 0x4f, 0x2e, 0x1b,
-	0xdf, 0x58, 0x60, 0xa1, 0x45, 0xb3, 0xf1, 0x5c, 0xb8, 0xdf, 0x3b, 0xa0, 0x12, 0xb2, 0x61, 0x2f,
-	0xc2, 0xbe, 0xec, 0xd1, 0xe6, 0x72, 0xaf, 0x1f, 0x7f, 0x66, 0x9d, 0x08, 0xf1, 0xc1, 0x87, 0x88,
-	0x44, 0x07, 0x5c, 0x0f, 0x68, 0x66, 0x87, 0xf4, 0x29, 0x5c, 0x07, 0xd3, 0x21, 0xdb, 0xa7, 0xea,
-	0x62, 0x26, 0xdf, 0xc4, 0x48, 0x4e, 0x6b, 0xfc, 0x6e, 0x81, 0xf3, 0x27, 0x68, 0xc0, 0x4f, 0xc0,
-	0x3c, 0x97, 0xf0, 0xe1, 0xbf, 0x8b, 0xd9, 0x8d, 0x77, 0xcd, 0x70, 0xbd, 0x7c, 0x7c, 0xb8, 0xee,
-	0xe0, 0x3e, 0x0a, 0xc6, 0x4d, 0x1c, 0x14, 0x46, 0x6c, 0x13, 0x07, 0x7a, 0xc4, 0xce, 0x29, 0x6b,
-	0xf9, 0xcf, 0xc8, 0x16, 0x98, 0x7b, 0x8c, 0x48, 0xe4, 0x67, 0x7f, 0x63, 0x6f, 0xf2, 0x1b, 0x32,
-	0x2b, 0x99, 0x19, 0x2e, 0x47, 0xad, 0x60, 0x71, 0x8f, 0x0b, 0x46, 0xb1, 0xaa, 0xde, 0x69, 0xef,
-	0x00, 0xb8, 0xf1, 0xb3, 0x05, 0xe6, 0xf2, 0x79, 0x33, 0x40, 0x1c, 0xc3, 0x3a, 0x58, 0xda, 0xbc,
-	0xbf, 0xdb, 0x79, 0x70, 0xcf, 0xf5, 0xfc, 0xf6, 0xd6, 0x7a, 0xc7, 0xf5, 0x1f, 0xec, 0x76, 0xda,
-	0xee, 0x66, 0xeb, 0x4e, 0xcb, 0x6d, 0x56, 0x27, 0xe0, 0x55, 0xb0, 0x78, 0x44, 0xee, 0xb9, 0x77,
-	0x5b, 0x9d, 0xae, 0xeb, 0xb9, 0xcd, 0xaa, 0x75, 0x02, 0xbd, 0xb5, 0xdb, 0xea, 0xb6, 0xd6, 0x77,
-	0x5a, 0x0f, 0xdd, 0x66, 0x75, 0x12, 0x5e, 0x06, 0x97, 0x8e, 0xc8, 0x77, 0xd6, 0x1f, 0xec, 0x6e,
-	0x6e, 0xb9, 0xcd, 0x6a, 0x09, 0x2e, 0x81, 0x8b, 0x47, 0x84, 0x9d, 0xee, 0xfd, 0x76, 0xdb, 0x6d,
-	0x56, 0xcb, 0x27, 0xc8, 0x9a, 0xee, 0x8e, 0xdb, 0x75, 0x9b, 0xd5, 0x33, 0x4b, 0xe5, 0xcf, 0xbf,
-	0xad, 0x4f, 0x6c, 0xb4, 0x9e, 0xbd, 0xac, 0x5b, 0xcf, 0x5f, 0xd6, 0xad, 0x3f, 0x5f, 0xd6, 0xad,
-	0xa7, 0xaf, 0xea, 0x13, 0xcf, 0x5f, 0xd5, 0x27, 0x7e, 0x7d, 0x55, 0x9f, 0x78, 0xe8, 0xf4, 0x89,
-	0x18, 0x0c, 0x7b, 0x76, 0xc0, 0x62, 0x07, 0x45, 0x11, 0xa1, 0x3d, 0x22, 0xb8, 0xa3, 0x7e, 0x33,
-	0x9f, 0x38, 0x87, 0xff, 0xcf, 0xc5, 0x38, 0xc1, 0xbc, 0x37, 0xa5, 0xf2, 0xfb, 0xce, 0xdf, 0x01,
-	0x00, 0x00, 0xff, 0xff, 0x63, 0x94, 0x07, 0xf6, 0xbd, 0x0b, 0x00, 0x00,
+	0x4f, 0x79, 0xb2, 0xf2, 0x5e, 0x66, 0x9e, 0x83, 0x84, 0x10, 0x1c, 0x22, 0xdb, 0x3b, 0x89, 0x17,
+	0x3b, 0xce, 0x6a, 0x76, 0x03, 0x52, 0x04, 0x1a, 0xf5, 0xce, 0x74, 0x76, 0x3b, 0x9e, 0xe9, 0x1e,
+	0x4d, 0xf7, 0xae, 0xb3, 0x9c, 0x39, 0x70, 0x0c, 0x37, 0x6e, 0x20, 0x71, 0xe1, 0xc8, 0x01, 0x71,
+	0xe4, 0x1c, 0x6e, 0x11, 0x27, 0x84, 0x50, 0x40, 0xc9, 0x81, 0xff, 0x81, 0x13, 0xea, 0x8f, 0x19,
+	0x8f, 0x3f, 0x22, 0x1c, 0x71, 0x19, 0x75, 0xff, 0xaa, 0x7e, 0xd5, 0x55, 0xd5, 0xd5, 0x55, 0x03,
+	0x96, 0x47, 0x08, 0x71, 0x27, 0x49, 0xd9, 0x88, 0x84, 0x38, 0x75, 0x46, 0x6b, 0xf9, 0xda, 0x4e,
+	0x52, 0x26, 0x18, 0xac, 0x4a, 0x05, 0x3b, 0x07, 0x47, 0x6b, 0x4b, 0xe7, 0x50, 0x4c, 0x28, 0x73,
+	0xd4, 0x57, 0x2b, 0x2d, 0x2d, 0x06, 0x8c, 0xc7, 0x8c, 0xfb, 0x6a, 0xe7, 0xe8, 0x8d, 0x11, 0x2d,
+	0xf4, 0x59, 0x9f, 0x69, 0x5c, 0xae, 0x0c, 0xfa, 0x1f, 0xad, 0xe3, 0x60, 0x69, 0x95, 0x06, 0xd8,
+	0x19, 0xad, 0xf5, 0xb0, 0x40, 0x6b, 0x39, 0x60, 0xf4, 0xea, 0x7d, 0xc6, 0xfa, 0x11, 0x76, 0xd4,
+	0xae, 0x37, 0x7c, 0xe4, 0x84, 0xc3, 0x14, 0x09, 0xc2, 0xa8, 0x91, 0x2f, 0x1f, 0x95, 0x0b, 0x12,
+	0x63, 0x2e, 0x50, 0x9c, 0x64, 0x0a, 0xa4, 0x17, 0x38, 0x01, 0x4b, 0xb1, 0x13, 0x44, 0x04, 0x53,
+	0x21, 0x23, 0xd4, 0x2b, 0xa3, 0xe0, 0x48, 0x85, 0x88, 0xf4, 0x07, 0x42, 0xc3, 0xdc, 0x11, 0x98,
+	0x86, 0x38, 0x8d, 0x89, 0x56, 0x3e, 0xd8, 0x19, 0x02, 0x54, 0x19, 0x1b, 0xad, 0x39, 0xfb, 0x24,
+	0xcd, 0xdc, 0xbc, 0x52, 0xe0, 0x04, 0xe9, 0x38, 0x11, 0xcc, 0xd9, 0xc3, 0x63, 0x93, 0x82, 0xc6,
+	0x97, 0x25, 0x30, 0xd5, 0x46, 0x29, 0x8a, 0x39, 0x7c, 0x07, 0xd4, 0x44, 0x3a, 0xe4, 0x82, 0xd0,
+	0xbe, 0x9f, 0xe0, 0x94, 0xb0, 0xd0, 0x7f, 0x94, 0xa2, 0x40, 0x46, 0x54, 0xb3, 0x56, 0xac, 0xd5,
+	0x19, 0xef, 0x62, 0x26, 0x6f, 0x2b, 0xf1, 0x1d, 0x23, 0x85, 0x1d, 0x70, 0x5e, 0x1e, 0xec, 0xcb,
+	0x00, 0xd9, 0x50, 0x18, 0x76, 0x6d, 0x72, 0xc5, 0x5a, 0xad, 0xdc, 0x5a, 0xb4, 0x75, 0x1e, 0xec,
+	0x2c, 0x0f, 0x76, 0xd3, 0xe4, 0x69, 0x63, 0xfa, 0xd9, 0x8b, 0xe5, 0x89, 0x2f, 0x7e, 0x5b, 0xb6,
+	0xbc, 0x73, 0x92, 0xdf, 0xd5, 0x74, 0x6d, 0x1c, 0xae, 0x82, 0x6a, 0x2f, 0x62, 0xc1, 0x1e, 0x97,
+	0xe6, 0x7c, 0x9c, 0xb0, 0x60, 0x50, 0x2b, 0xad, 0x58, 0xab, 0x25, 0x6f, 0x5e, 0xe3, 0x6d, 0x9c,
+	0xba, 0x12, 0x85, 0x2d, 0x70, 0x2d, 0x46, 0x4f, 0xfc, 0xac, 0x0e, 0xfc, 0x80, 0x51, 0x8e, 0x29,
+	0x1f, 0x72, 0x7f, 0x84, 0x22, 0x12, 0x22, 0xc1, 0x52, 0x5e, 0x2b, 0x2b, 0x6a, 0x3d, 0x46, 0x4f,
+	0xda, 0x46, 0x6f, 0x33, 0x53, 0xfb, 0x20, 0xd7, 0x82, 0x01, 0xb8, 0xf0, 0x08, 0x63, 0x7d, 0xa4,
+	0x3a, 0xc5, 0x47, 0x31, 0x1b, 0x52, 0x51, 0x3b, 0x23, 0x13, 0xb0, 0xf1, 0x7f, 0xe9, 0xf0, 0x2f,
+	0x2f, 0x96, 0x2f, 0xe8, 0x12, 0xe1, 0xe1, 0x9e, 0x4d, 0x98, 0x13, 0x23, 0x31, 0xb0, 0x5b, 0x54,
+	0xfc, 0xf4, 0xdd, 0x4d, 0x60, 0xea, 0xab, 0x45, 0xc5, 0x37, 0x7f, 0x7c, 0x7b, 0xc3, 0xf2, 0xa0,
+	0x34, 0xd7, 0xc6, 0xe9, 0x86, 0x34, 0xb6, 0xae, 0x6c, 0xc1, 0xff, 0x01, 0x18, 0x13, 0xea, 0x87,
+	0x38, 0x61, 0x9c, 0x08, 0x7d, 0x0e, 0xaf, 0x4d, 0xad, 0x58, 0xab, 0x65, 0xaf, 0x1a, 0x13, 0xda,
+	0xd4, 0x02, 0x45, 0xe1, 0x8d, 0xff, 0x82, 0xca, 0x7a, 0x18, 0xa6, 0x98, 0xf3, 0x1d, 0xc2, 0x05,
+	0xbc, 0x02, 0x66, 0x90, 0xde, 0x62, 0x5e, 0xb3, 0x56, 0x4a, 0xab, 0xb3, 0xde, 0x01, 0xd0, 0xf8,
+	0x08, 0x2c, 0xe6, 0xd1, 0x74, 0xb0, 0xd8, 0x1c, 0x20, 0xda, 0xc7, 0x6d, 0x14, 0xec, 0x61, 0xc1,
+	0xe1, 0x6d, 0x50, 0x8e, 0x08, 0x17, 0x8a, 0x55, 0xb9, 0x75, 0xdd, 0x56, 0xaf, 0x67, 0xb4, 0x66,
+	0xbf, 0x8e, 0xd1, 0x44, 0x02, 0x6d, 0x94, 0x65, 0xc8, 0x9e, 0x22, 0x36, 0x3e, 0xb7, 0x40, 0x6d,
+	0x1b, 0x8f, 0xd7, 0x39, 0x27, 0x7d, 0x1a, 0x63, 0x2a, 0x3c, 0x9c, 0x44, 0x28, 0xc0, 0x72, 0x09,
+	0xff, 0x0d, 0xe6, 0xf2, 0x1b, 0x90, 0x0e, 0xa9, 0x9a, 0x99, 0xf5, 0x66, 0x33, 0x50, 0x06, 0x01,
+	0xdf, 0x05, 0x20, 0x49, 0xf1, 0xc8, 0x0f, 0xfc, 0x3d, 0x3c, 0x36, 0x05, 0x72, 0xc5, 0x2e, 0xd4,
+	0xb1, 0xae, 0x50, 0xbb, 0x3d, 0xec, 0x45, 0x24, 0xd8, 0xc6, 0x63, 0x6f, 0x5a, 0xea, 0x6f, 0x6e,
+	0xe3, 0x31, 0x5c, 0x00, 0x67, 0x12, 0xb6, 0x8f, 0x53, 0x53, 0x05, 0x7a, 0xd3, 0xf8, 0xca, 0x02,
+	0x97, 0xf2, 0x00, 0xe4, 0x95, 0x0e, 0x63, 0x9c, 0xb6, 0x87, 0x3d, 0xc9, 0x58, 0x06, 0x95, 0xc0,
+	0x20, 0x3e, 0x09, 0x95, 0x43, 0x65, 0x0f, 0x64, 0x50, 0x2b, 0x3c, 0xee, 0xf3, 0xe4, 0x09, 0x3e,
+	0xdf, 0x06, 0xb3, 0xb9, 0x15, 0xe9, 0x75, 0xe9, 0x14, 0x5e, 0xe7, 0xe7, 0x6e, 0xe3, 0x71, 0xe3,
+	0xd3, 0xa2, 0x8b, 0x1b, 0xe3, 0xcc, 0x49, 0x65, 0xfc, 0x34, 0x2e, 0xe6, 0x0a, 0x45, 0x17, 0x83,
+	0xa2, 0x95, 0x63, 0x71, 0x94, 0x8e, 0xc7, 0xd1, 0xf8, 0xc1, 0x02, 0x0b, 0xc5, 0xb3, 0x79, 0x97,
+	0xb5, 0xd3, 0x21, 0xc5, 0x7f, 0xef, 0xc3, 0x6d, 0x30, 0x9d, 0x48, 0x4d, 0x5f, 0x70, 0x73, 0x67,
+	0x4b, 0xc7, 0x1e, 0x75, 0x37, 0x6b, 0x6e, 0xfa, 0x55, 0x3f, 0x95, 0xaf, 0xfa, 0xac, 0x62, 0x75,
+	0x39, 0x6c, 0x82, 0xf9, 0x43, 0x41, 0x70, 0x93, 0xc4, 0xab, 0xf6, 0xd1, 0x0e, 0x6e, 0x17, 0x6a,
+	0xdd, 0x9b, 0x2b, 0x06, 0xc9, 0x1b, 0xdf, 0x5b, 0x00, 0x1e, 0x7f, 0xb4, 0xf2, 0x39, 0x1d, 0x7a,
+	0xfa, 0xc5, 0xea, 0xab, 0x26, 0x85, 0xc7, 0xae, 0x52, 0x95, 0x57, 0xd1, 0x64, 0xa1, 0x8a, 0xe0,
+	0x7b, 0x00, 0x24, 0xea, 0xf2, 0x4e, 0x7d, 0xc3, 0x33, 0x49, 0xb6, 0x94, 0xf9, 0x7b, 0xcc, 0x08,
+	0xf5, 0x07, 0x58, 0xb6, 0x6a, 0xd3, 0x69, 0x80, 0x84, 0xb6, 0x14, 0xd2, 0x08, 0x41, 0x35, 0x4b,
+	0xfc, 0x3d, 0x2c, 0x50, 0x88, 0x04, 0x82, 0x10, 0x94, 0x29, 0x8a, 0xb1, 0xe9, 0xac, 0x6a, 0x0d,
+	0x57, 0x40, 0x25, 0xc4, 0x3c, 0x48, 0x49, 0xa2, 0x9a, 0xee, 0xa4, 0x12, 0x15, 0x21, 0xb8, 0x04,
+	0xa6, 0x63, 0x63, 0x41, 0x79, 0x39, 0xe3, 0xe5, 0xfb, 0xc6, 0xb3, 0x12, 0x58, 0xc9, 0x8e, 0x69,
+	0x51, 0x22, 0x08, 0x8a, 0xc8, 0x27, 0xaa, 0xd1, 0xaa, 0x06, 0x8f, 0x05, 0x4e, 0x39, 0xbc, 0x0b,
+	0xe6, 0x89, 0x96, 0x65, 0xee, 0x5a, 0xe6, 0x42, 0x49, 0x2f, 0xb0, 0xe5, 0x30, 0xb2, 0xcd, 0x08,
+	0x1a, 0xad, 0xd9, 0xda, 0x7d, 0xd3, 0x02, 0xe6, 0x0c, 0x4f, 0x83, 0xf0, 0x1a, 0x98, 0xed, 0x63,
+	0x8a, 0x39, 0xe1, 0xfe, 0x00, 0xf1, 0x81, 0x29, 0xcb, 0x8a, 0xc1, 0xb6, 0x10, 0x1f, 0xc8, 0xbc,
+	0xf4, 0x08, 0x45, 0xe9, 0x58, 0x6b, 0xe8, 0x9a, 0x04, 0x1a, 0x52, 0x0a, 0x9b, 0x00, 0xf0, 0x04,
+	0xed, 0x53, 0x35, 0x38, 0x54, 0xde, 0x4e, 0x5b, 0x59, 0x33, 0x8a, 0x27, 0x25, 0x70, 0x17, 0x54,
+	0x87, 0xb4, 0xc7, 0x68, 0x78, 0x30, 0xb7, 0x54, 0xb7, 0x3e, 0xe5, 0xe4, 0xf9, 0x57, 0x4e, 0x36,
+	0x73, 0xe7, 0x35, 0xc3, 0x6c, 0xea, 0x1f, 0x0d, 0xb3, 0x9b, 0x00, 0x0e, 0x08, 0x17, 0x2c, 0x25,
+	0x01, 0x8a, 0x7c, 0x4c, 0x45, 0x4a, 0x30, 0xaf, 0x9d, 0x55, 0x95, 0x72, 0xee, 0x40, 0xe2, 0x6a,
+	0x41, 0x63, 0x19, 0x54, 0xf2, 0x9b, 0x0c, 0x39, 0xac, 0x82, 0x12, 0x09, 0x75, 0xb7, 0x2f, 0x7b,
+	0x72, 0xd9, 0xf8, 0xd3, 0x02, 0x0b, 0x2d, 0x9a, 0x8d, 0xe7, 0xc2, 0xfd, 0xde, 0x01, 0x95, 0x90,
+	0x0d, 0x7b, 0x11, 0xf6, 0x65, 0x8f, 0x36, 0x97, 0x7b, 0xfd, 0xf8, 0x33, 0xeb, 0x44, 0x88, 0x0f,
+	0xde, 0x47, 0x24, 0x3a, 0xe0, 0x7a, 0x40, 0x33, 0x3b, 0xa4, 0x4f, 0xe1, 0x3a, 0x98, 0x0e, 0xd9,
+	0x3e, 0x55, 0x17, 0x33, 0xf9, 0x26, 0x46, 0x72, 0x1a, 0xfc, 0x10, 0x5c, 0xc8, 0xd6, 0x7e, 0x3f,
+	0x45, 0x01, 0xce, 0x52, 0x59, 0x3a, 0x7d, 0x2a, 0xcf, 0x67, 0x16, 0xee, 0x4a, 0x03, 0x3a, 0x99,
+	0x8d, 0x5f, 0x2d, 0x70, 0xfe, 0x84, 0xa3, 0xe1, 0xc7, 0x60, 0x9e, 0x4b, 0xf8, 0xf0, 0x6f, 0xcb,
+	0xec, 0xc6, 0xdb, 0x66, 0x6a, 0x5f, 0x3e, 0x3e, 0xb5, 0x77, 0x70, 0x1f, 0x05, 0xe3, 0x26, 0x0e,
+	0x0a, 0xb3, 0xbb, 0x89, 0x03, 0x3d, 0xbb, 0xe7, 0x94, 0xb5, 0xfc, 0x2f, 0x67, 0x0b, 0xcc, 0x3d,
+	0x46, 0x24, 0xf2, 0xb3, 0xdf, 0xbc, 0x37, 0xf9, 0xbf, 0x99, 0x95, 0xcc, 0x0c, 0x97, 0x33, 0x5c,
+	0xb0, 0xb8, 0xc7, 0x05, 0xa3, 0x58, 0x65, 0x63, 0xda, 0x3b, 0x00, 0x6e, 0xfc, 0x68, 0x81, 0xb9,
+	0x7c, 0x90, 0x0d, 0x10, 0xc7, 0xb0, 0x0e, 0x96, 0x36, 0xef, 0xef, 0x76, 0x1e, 0xdc, 0x73, 0x3d,
+	0xbf, 0xbd, 0xb5, 0xde, 0x71, 0xfd, 0x07, 0xbb, 0x9d, 0xb6, 0xbb, 0xd9, 0xba, 0xd3, 0x72, 0x9b,
+	0xd5, 0x09, 0x78, 0x15, 0x2c, 0x1e, 0x91, 0x7b, 0xee, 0xdd, 0x56, 0xa7, 0xeb, 0x7a, 0x6e, 0xb3,
+	0x6a, 0x9d, 0x40, 0x6f, 0xed, 0xb6, 0xba, 0xad, 0xf5, 0x9d, 0xd6, 0x43, 0xb7, 0x59, 0x9d, 0x84,
+	0x97, 0xc1, 0xa5, 0x23, 0xf2, 0x9d, 0xf5, 0x07, 0xbb, 0x9b, 0x5b, 0x6e, 0xb3, 0x5a, 0x82, 0x4b,
+	0xe0, 0xe2, 0x11, 0x61, 0xa7, 0x7b, 0xbf, 0xdd, 0x76, 0x9b, 0xd5, 0xf2, 0x09, 0xb2, 0xa6, 0xbb,
+	0xe3, 0x76, 0xdd, 0x66, 0xf5, 0xcc, 0x52, 0xf9, 0xb3, 0xaf, 0xeb, 0x13, 0x1b, 0xad, 0x67, 0x2f,
+	0xeb, 0xd6, 0xf3, 0x97, 0x75, 0xeb, 0xf7, 0x97, 0x75, 0xeb, 0xe9, 0xab, 0xfa, 0xc4, 0xf3, 0x57,
+	0xf5, 0x89, 0x9f, 0x5f, 0xd5, 0x27, 0x1e, 0x3a, 0x7d, 0x22, 0x06, 0xc3, 0x9e, 0x1d, 0xb0, 0xd8,
+	0x41, 0x51, 0x44, 0x68, 0x8f, 0x08, 0xee, 0xa8, 0xff, 0xd7, 0x27, 0xce, 0xe1, 0x1f, 0x7f, 0x31,
+	0x4e, 0x30, 0xef, 0x4d, 0xa9, 0xfc, 0xbe, 0xf5, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0xea, 0xb8,
+	0x71, 0x09, 0x16, 0x0c, 0x00, 0x00,
 }
 
 func (m *Params) Marshal() (dAtA []byte, err error) {
@@ -1584,6 +1598,14 @@ func (m *InfractionParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	n13, err13 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.DowntimeGracePeriod, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.DowntimeGracePeriod):])
+	if err13 != nil {
+		return 0, err13
+	}
+	i -= n13
+	i = encodeVarintProvider(dAtA, i, uint64(n13))
+	i--
+	dAtA[i] = 0x1a
 	if m.Downtime != nil {
 		{
 			size, err := m.Downtime.MarshalToSizedBuffer(dAtA[:i])
@@ -1641,12 +1663,12 @@ func (m *SlashJailParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x18
 	}
-	n15, err15 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.JailDuration, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.JailDuration):])
-	if err15 != nil {
-		return 0, err15
+	n16, err16 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.JailDuration, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.JailDuration):])
+	if err16 != nil {
+		return 0, err16
 	}
-	i -= n15
-	i = encodeVarintProvider(dAtA, i, uint64(n15))
+	i -= n16
+	i = encodeVarintProvider(dAtA, i, uint64(n16))
 	i--
 	dAtA[i] = 0x12
 	{
@@ -1909,6 +1931,8 @@ func (m *InfractionParameters) Size() (n int) {
 		l = m.Downtime.Size()
 		n += 1 + l + sovProvider(uint64(l))
 	}
+	l = github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.DowntimeGracePeriod)
+	n += 1 + l + sovProvider(uint64(l))
 	return n
 }
 
@@ -3659,6 +3683,39 @@ func (m *InfractionParameters) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DowntimeGracePeriod", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProvider
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthProvider
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthProvider
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_cosmos_gogoproto_types.StdDurationUnmarshal(&m.DowntimeGracePeriod, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipProvider(dAtA[iNdEx:])
diff --git a/x/vaas/provider/types/tx.pb.go b/x/vaas/provider/types/tx.pb.go
index c3df744..e01db4d 100644
--- a/x/vaas/provider/types/tx.pb.go
+++ b/x/vaas/provider/types/tx.pb.go
@@ -376,11 +376,12 @@ var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo
 
 // MsgRemoveConsumer defines the message used to remove (and stop) a consumer chain.
 // If it passes, all the consumer chain's state is eventually removed from the provider chain.
+// Only the governance authority can remove a consumer chain.
 type MsgRemoveConsumer struct {
 	// the consumer id of the consumer chain to be stopped
 	ConsumerId uint64 `protobuf:"varint,1,opt,name=consumer_id,json=consumerId,proto3" json:"consumer_id,omitempty"`
-	// the address of the owner of the consumer chain to be stopped
-	Owner string `protobuf:"bytes,2,opt,name=owner,proto3" json:"owner,omitempty"`
+	// authority is the address of the governance account.
+	Authority string `protobuf:"bytes,2,opt,name=authority,proto3" json:"authority,omitempty"`
 }
 
 func (m *MsgRemoveConsumer) Reset()         { *m = MsgRemoveConsumer{} }
@@ -423,9 +424,9 @@ func (m *MsgRemoveConsumer) GetConsumerId() uint64 {
 	return 0
 }
 
-func (m *MsgRemoveConsumer) GetOwner() string {
+func (m *MsgRemoveConsumer) GetAuthority() string {
 	if m != nil {
-		return m.Owner
+		return m.Authority
 	}
 	return ""
 }
@@ -1104,94 +1105,93 @@ func init() {
 func init() { proto.RegisterFile("vaas/provider/v1/tx.proto", fileDescriptor_a07778b1d094765c) }
 
 var fileDescriptor_a07778b1d094765c = []byte{
-	// 1378 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x4d, 0x6c, 0x1b, 0x45,
-	0x1b, 0xce, 0x26, 0x69, 0xbe, 0x66, 0x92, 0x2f, 0x25, 0xdb, 0xb4, 0xb1, 0x4d, 0xb1, 0x53, 0x03,
-	0x6d, 0x28, 0xed, 0x6e, 0x13, 0xa0, 0x95, 0xa2, 0x0a, 0xa9, 0x49, 0xa8, 0x88, 0x90, 0x45, 0xb4,
-	0x15, 0x45, 0x42, 0x08, 0x6b, 0x76, 0x77, 0xba, 0x1e, 0xc5, 0x3b, 0x63, 0x76, 0xc6, 0x4e, 0x83,
-	0x84, 0x84, 0x38, 0x20, 0x7a, 0x83, 0x23, 0xb7, 0x1e, 0x11, 0x12, 0x52, 0x0f, 0x3d, 0x73, 0xee,
-	0xb1, 0xf4, 0x84, 0x38, 0x14, 0x94, 0x1e, 0xca, 0x89, 0x03, 0x67, 0x0e, 0x68, 0x67, 0x67, 0xc7,
-	0x6b, 0x7b, 0xd6, 0x76, 0x0b, 0xea, 0x25, 0xf1, 0xcc, 0xfb, 0xcc, 0xfb, 0xf3, 0x3c, 0xf3, 0xf3,
-	0x6a, 0x41, 0xb1, 0x03, 0x21, 0xb3, 0x5b, 0x11, 0xed, 0x60, 0x1f, 0x45, 0x76, 0x67, 0xcd, 0xe6,
-	0xb7, 0xac, 0x56, 0x44, 0x39, 0x35, 0x5f, 0x88, 0x4d, 0x56, 0x6a, 0xb2, 0x3a, 0x6b, 0xa5, 0x45,
-	0x18, 0x62, 0x42, 0x6d, 0xf1, 0x37, 0x01, 0x95, 0xca, 0x1e, 0x65, 0x21, 0x65, 0xb6, 0x0b, 0x19,
-	0xb2, 0x3b, 0x6b, 0x2e, 0xe2, 0x70, 0xcd, 0xf6, 0x28, 0x26, 0xd2, 0xbe, 0x2c, 0xed, 0x21, 0x0b,
-	0x62, 0xe7, 0x21, 0x0b, 0xa4, 0xa1, 0x98, 0x18, 0xea, 0x62, 0x64, 0x27, 0x03, 0x69, 0x5a, 0x0a,
-	0x68, 0x40, 0x93, 0xf9, 0xf8, 0x97, 0x9c, 0x3d, 0x15, 0x50, 0x1a, 0x34, 0x91, 0x0d, 0x5b, 0xd8,
-	0x86, 0x84, 0x50, 0x0e, 0x39, 0xa6, 0x24, 0x5d, 0x53, 0x94, 0x56, 0x31, 0x72, 0xdb, 0x37, 0x6d,
-	0x48, 0x0e, 0xd2, 0x14, 0xfb, 0x4d, 0x7e, 0x3b, 0x12, 0x6b, 0xa5, 0xbd, 0xd2, 0x6f, 0xe7, 0x38,
-	0x44, 0x8c, 0xc3, 0xb0, 0x95, 0x02, 0xb0, 0xeb, 0xd9, 0x1e, 0x8d, 0x90, 0xed, 0x35, 0x31, 0x22,
-	0x3c, 0x2e, 0x24, 0xf9, 0x25, 0x01, 0x76, 0x0c, 0x68, 0xe2, 0xa0, 0xc1, 0x93, 0x69, 0x66, 0x73,
-	0x44, 0x7c, 0x14, 0x85, 0x38, 0x01, 0x77, 0x47, 0xa9, 0xc7, 0x8c, 0x9d, 0x1f, 0xb4, 0x10, 0xb3,
-	0x51, 0x4c, 0x32, 0xf1, 0x50, 0x0a, 0x18, 0x90, 0x45, 0xe9, 0x20, 0x00, 0xd5, 0x5f, 0x0d, 0xb0,
-	0x54, 0x63, 0xc1, 0x55, 0xc6, 0x70, 0x40, 0xb6, 0x28, 0x61, 0xed, 0x10, 0x45, 0xef, 0xa1, 0x03,
-	0xb3, 0x02, 0xe6, 0x3c, 0x39, 0xac, 0x63, 0xbf, 0x60, 0xac, 0x18, 0xab, 0xd3, 0x0e, 0x48, 0xa7,
-	0x76, 0x7c, 0xf3, 0x32, 0xf8, 0x7f, 0xea, 0xab, 0x0e, 0x7d, 0x3f, 0x2a, 0x4c, 0xae, 0x18, 0xab,
-	0xb3, 0x9b, 0xe6, 0x5f, 0x8f, 0x2a, 0x0b, 0x07, 0x30, 0x6c, 0x6e, 0x54, 0xe3, 0x59, 0xc4, 0x58,
-	0xd5, 0x99, 0x4f, 0x81, 0x57, 0x7d, 0x3f, 0x32, 0x4f, 0x83, 0x79, 0xe5, 0x79, 0x0f, 0x1d, 0x14,
-	0xa6, 0xe2, 0x75, 0x8e, 0x8a, 0x16, 0x07, 0xbf, 0x08, 0x66, 0xe2, 0x7c, 0x50, 0x54, 0x98, 0x16,
-	0x4e, 0x0b, 0x0f, 0xef, 0x5d, 0x58, 0x92, 0xda, 0x5e, 0x4d, 0xbc, 0x5e, 0xe7, 0x11, 0x26, 0x81,
-	0x23, 0x71, 0x1b, 0xc7, 0xbf, 0xbe, 0x53, 0x99, 0xf8, 0xe3, 0x4e, 0x65, 0xe2, 0xcb, 0x27, 0x77,
-	0xcf, 0xc9, 0xc9, 0x6a, 0x19, 0x9c, 0xd2, 0xd5, 0xe6, 0x20, 0xd6, 0xa2, 0x84, 0xa1, 0xea, 0xa1,
-	0x01, 0x5e, 0xaa, 0xb1, 0xe0, 0x7a, 0xdb, 0x0d, 0x31, 0x4f, 0x01, 0x35, 0xcc, 0x5c, 0xd4, 0x80,
-	0x1d, 0x4c, 0xdb, 0x91, 0x79, 0x09, 0xcc, 0x32, 0x61, 0xe5, 0x28, 0x12, 0x1c, 0x0c, 0xcb, 0xa5,
-	0x0b, 0x35, 0x77, 0xc1, 0x7c, 0x98, 0xf1, 0x23, 0xb8, 0x99, 0x5b, 0x3f, 0x6f, 0x61, 0xd7, 0xb3,
-	0xb2, 0x02, 0x5b, 0x19, 0x49, 0x3b, 0x6b, 0x56, 0x36, 0xb6, 0xd3, 0xe3, 0xa1, 0x5f, 0x8f, 0xa9,
-	0x7e, 0x3d, 0x36, 0x4e, 0x66, 0x19, 0xe8, 0xa6, 0x52, 0x3d, 0x0b, 0x5e, 0x1d, 0x5a, 0xa3, 0x62,
-	0xe3, 0xe7, 0x49, 0x0d, 0x1b, 0xdb, 0xb4, 0xed, 0x36, 0xd1, 0x0d, 0xca, 0x31, 0x09, 0x9e, 0x99,
-	0x8d, 0x3a, 0x58, 0xf6, 0xdb, 0xad, 0x26, 0xf6, 0x20, 0x47, 0xf5, 0x0e, 0xe5, 0xa8, 0x9e, 0x6e,
-	0x53, 0x49, 0xcc, 0xd9, 0x2c, 0x0f, 0x62, 0x23, 0x5b, 0xdb, 0xe9, 0x82, 0x1b, 0x94, 0xa3, 0x77,
-	0x24, 0xdc, 0x39, 0xe1, 0xeb, 0xa6, 0xcd, 0x4f, 0xc0, 0x32, 0x26, 0x37, 0x23, 0xe8, 0xc5, 0xc7,
-	0xb1, 0xee, 0x36, 0xa9, 0xb7, 0x57, 0x6f, 0x20, 0xe8, 0xa3, 0x48, 0x10, 0x35, 0xb7, 0x7e, 0x66,
-	0x14, 0xf3, 0xef, 0x0a, 0xb4, 0x73, 0xa2, 0xeb, 0x66, 0x33, 0xf6, 0x92, 0x4c, 0xf7, 0x93, 0x3f,
-	0xfd, 0xaf, 0xc8, 0xcf, 0x52, 0xaa, 0xc8, 0xff, 0xd6, 0x00, 0xc7, 0x6a, 0x2c, 0xf8, 0xa0, 0xe5,
-	0x43, 0x8e, 0x76, 0x61, 0x04, 0x43, 0x16, 0xd3, 0x0d, 0xdb, 0xbc, 0x41, 0x23, 0xcc, 0x0f, 0x46,
-	0xd3, 0xad, 0xa0, 0xe6, 0x25, 0x30, 0xd3, 0x12, 0x1e, 0x24, 0xbb, 0x05, 0xab, 0xff, 0x06, 0xb6,
-	0x92, 0x08, 0x9b, 0xd3, 0xf7, 0x1f, 0x55, 0x26, 0x1c, 0x89, 0xde, 0x58, 0x10, 0xc9, 0x2b, 0x3f,
-	0xd5, 0x22, 0x58, 0xee, 0x4b, 0x49, 0xa5, 0xdb, 0x02, 0x8b, 0x35, 0x16, 0x38, 0x28, 0xa4, 0x1d,
-	0x94, 0xd6, 0x35, 0xfa, 0xca, 0xb0, 0xc0, 0x11, 0xba, 0x1f, 0x9f, 0xea, 0xc9, 0x11, 0xc5, 0x24,
-	0xb0, 0x0d, 0x10, 0x27, 0x94, 0xfc, 0xae, 0xbe, 0x08, 0x8a, 0x03, 0x11, 0x55, 0x3a, 0x3f, 0x4e,
-	0x8a, 0x7c, 0xb6, 0x22, 0x04, 0x79, 0x37, 0x9f, 0x67, 0xdd, 0xae, 0x45, 0x70, 0xd4, 0x6b, 0x40,
-	0x4c, 0xe2, 0x22, 0x44, 0xa6, 0xce, 0xff, 0xc4, 0x78, 0xc7, 0x37, 0xb7, 0xc1, 0xd1, 0x10, 0x71,
-	0xe8, 0x43, 0x0e, 0xe5, 0xce, 0xaa, 0x0e, 0x92, 0xab, 0x4e, 0x99, 0x44, 0x4a, 0x9a, 0xd5, 0x4a,
-	0x93, 0x82, 0x22, 0x26, 0x98, 0x63, 0xd8, 0xc4, 0x9f, 0x89, 0x17, 0xa4, 0x2e, 0x14, 0x40, 0x1c,
-	0x45, 0x4c, 0x6c, 0xae, 0xb9, 0xf5, 0xf5, 0x7c, 0xb7, 0x3b, 0x3d, 0x4b, 0x77, 0xd5, 0x4a, 0xa7,
-	0x80, 0x73, 0x2c, 0x52, 0xd9, 0xee, 0xb6, 0xbc, 0x22, 0xc8, 0xec, 0xa5, 0x2b, 0x25, 0x73, 0xa4,
-	0x8c, 0xd5, 0xdb, 0x53, 0x82, 0xed, 0x64, 0x63, 0x28, 0xb6, 0x95, 0xb8, 0xc6, 0x58, 0xe2, 0xf6,
-	0x87, 0x99, 0x1c, 0xd8, 0x2d, 0xdb, 0x60, 0x91, 0xa0, 0xfd, 0xba, 0x40, 0xd7, 0xe5, 0x5b, 0x92,
-	0x3c, 0x16, 0x43, 0x9c, 0x1f, 0x23, 0x68, 0xff, 0xfd, 0x78, 0x85, 0x9c, 0x36, 0xdf, 0xce, 0x28,
-	0x36, 0x3d, 0xae, 0x62, 0xe3, 0x6a, 0x75, 0xe4, 0xbf, 0xd7, 0xca, 0x5c, 0x01, 0xf3, 0x71, 0xd9,
-	0x6a, 0x07, 0xce, 0x88, 0x1d, 0x08, 0x08, 0xda, 0xdf, 0x4a, 0x36, 0xa1, 0xe6, 0x58, 0xf4, 0x4a,
-	0xd1, 0x3d, 0x16, 0x06, 0x28, 0xc5, 0xd7, 0x0f, 0x52, 0x77, 0xcf, 0x35, 0x84, 0xd8, 0x2e, 0x8a,
-	0xc4, 0xdd, 0xf6, 0xcc, 0xf7, 0xcb, 0x48, 0xe5, 0xce, 0x80, 0x19, 0x18, 0xd2, 0x36, 0xe1, 0x52,
-	0xae, 0x85, 0x87, 0xf7, 0x2e, 0x00, 0xe9, 0x75, 0x87, 0x70, 0x47, 0x5a, 0x07, 0x2e, 0x9c, 0x57,
-	0x40, 0x35, 0x3f, 0x5d, 0x55, 0xd5, 0x4f, 0x06, 0x38, 0x59, 0x63, 0xc1, 0xb5, 0x36, 0xf1, 0x33,
-	0xb8, 0x5d, 0x4a, 0x9b, 0x99, 0xbe, 0xc1, 0x18, 0xaf, 0x6f, 0x18, 0x5d, 0xcb, 0x95, 0x9e, 0x5a,
-	0xe6, 0xd6, 0x8b, 0x96, 0xf4, 0x17, 0x77, 0xaa, 0x96, 0xec, 0x54, 0xad, 0x2d, 0x8a, 0xc9, 0xe6,
-	0x6c, 0x7c, 0xcc, 0xbf, 0x7f, 0x72, 0xf7, 0x9c, 0xa1, 0x2a, 0xd4, 0xb6, 0x25, 0x2b, 0xa0, 0xac,
-	0xcf, 0x5f, 0x95, 0xf8, 0x67, 0x22, 0xdc, 0x87, 0x98, 0x37, 0xfc, 0x08, 0xee, 0x3f, 0x87, 0x32,
-	0x1b, 0x99, 0x32, 0xa7, 0x86, 0x97, 0xf9, 0x56, 0x5c, 0xe6, 0x0f, 0xbf, 0x55, 0x56, 0x03, 0xcc,
-	0x1b, 0x6d, 0xd7, 0xf2, 0x68, 0x28, 0xfb, 0x6e, 0xf9, 0xef, 0x02, 0xf3, 0xf7, 0x92, 0x76, 0x54,
-	0x2c, 0x60, 0x63, 0x50, 0x72, 0xdb, 0x10, 0xd2, 0xe7, 0x14, 0xac, 0xae, 0x26, 0x4f, 0x65, 0x69,
-	0x8c, 0xca, 0xf2, 0xe2, 0xd3, 0x66, 0x99, 0x26, 0x58, 0xfd, 0xce, 0x10, 0xef, 0xde, 0xf5, 0x7d,
-	0x84, 0x5a, 0xcf, 0x81, 0xf9, 0x93, 0x60, 0xc6, 0x47, 0x84, 0x86, 0x4c, 0x30, 0x3f, 0xeb, 0xc8,
-	0x91, 0x9e, 0xa7, 0xd3, 0xa0, 0x92, 0x93, 0x5a, 0xca, 0xd1, 0xfa, 0xdf, 0xb3, 0x60, 0xaa, 0xc6,
-	0x02, 0x73, 0x0f, 0x2c, 0x0e, 0x76, 0xf5, 0x67, 0x06, 0xaf, 0x2a, 0x5d, 0x87, 0x5c, 0xb2, 0xc6,
-	0xc3, 0x29, 0x61, 0xbe, 0x32, 0x40, 0x69, 0x48, 0x1b, 0x6d, 0x6b, 0xdd, 0xe5, 0x2f, 0x28, 0x5d,
-	0x7e, 0xca, 0x05, 0x43, 0x12, 0xe9, 0xe9, 0x60, 0xc7, 0x49, 0x24, 0xbb, 0x60, 0xac, 0x44, 0x74,
-	0x0d, 0x9d, 0xe9, 0x82, 0x85, 0xbe, 0x76, 0xe4, 0x65, 0xad, 0xab, 0x5e, 0x50, 0xe9, 0xf5, 0x31,
-	0x40, 0xd9, 0x18, 0x7d, 0x8f, 0xb0, 0x3e, 0x46, 0x2f, 0x28, 0x27, 0x86, 0xfe, 0x0d, 0x89, 0x63,
-	0xf4, 0xb5, 0x79, 0xfa, 0x18, 0xbd, 0xa0, 0x9c, 0x18, 0xfa, 0xf6, 0xcd, 0xfc, 0x18, 0xcc, 0xf7,
-	0x34, 0xbe, 0xa7, 0x87, 0x24, 0x98, 0x40, 0x4a, 0xaf, 0x8d, 0x84, 0x28, 0xef, 0x9f, 0x83, 0xe5,
-	0xbc, 0x17, 0xf0, 0xbc, 0x5e, 0x5d, 0x3d, 0xba, 0xf4, 0xe6, 0xd3, 0xa0, 0x55, 0xf8, 0x4f, 0xc1,
-	0x71, 0xdd, 0x53, 0xb5, 0xaa, 0x75, 0xa6, 0x41, 0x96, 0x2e, 0x8e, 0x8b, 0xcc, 0x56, 0x9c, 0xf7,
-	0x74, 0xe8, 0x2b, 0xce, 0x41, 0xe7, 0x54, 0x3c, 0xea, 0x96, 0xe6, 0x60, 0x49, 0x7b, 0x79, 0xea,
-	0x35, 0xd3, 0x41, 0x4b, 0x6b, 0x63, 0x43, 0xd3, 0xa8, 0xa5, 0x23, 0x5f, 0xc4, 0xcf, 0xcc, 0xe6,
-	0xce, 0xfd, 0xc3, 0xb2, 0xf1, 0xe0, 0xb0, 0x6c, 0xfc, 0x7e, 0x58, 0x36, 0xbe, 0x79, 0x5c, 0x9e,
-	0x78, 0xf0, 0xb8, 0x3c, 0xf1, 0xcb, 0xe3, 0xf2, 0xc4, 0x47, 0x76, 0xe6, 0x25, 0x80, 0xcd, 0x26,
-	0x26, 0x2e, 0xe6, 0xcc, 0x16, 0x1f, 0x48, 0x6e, 0xd9, 0xbd, 0xdf, 0x49, 0xc4, 0xb3, 0xe0, 0xce,
-	0x88, 0x4f, 0x24, 0x6f, 0xfc, 0x13, 0x00, 0x00, 0xff, 0xff, 0x90, 0xf9, 0xbf, 0x47, 0xdc, 0x12,
-	0x00, 0x00,
+	// 1376 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x4d, 0x6c, 0xdc, 0x44,
+	0x14, 0x8e, 0x93, 0x34, 0x34, 0x93, 0x90, 0x12, 0x37, 0x6d, 0x76, 0x4d, 0xd9, 0x4d, 0x17, 0x68,
+	0x43, 0x69, 0xed, 0x26, 0x40, 0x2b, 0x45, 0x15, 0x52, 0x93, 0x50, 0x11, 0xa1, 0x15, 0x91, 0x2b,
+	0x8a, 0x84, 0x10, 0xab, 0xb1, 0x3d, 0xf5, 0x8e, 0xb2, 0x9e, 0x59, 0x3c, 0xb3, 0x9b, 0x2e, 0x02,
+	0x09, 0x71, 0x40, 0xf4, 0x06, 0x47, 0x6e, 0x3d, 0x22, 0x24, 0xa4, 0x1e, 0x7a, 0xe6, 0xdc, 0x63,
+	0xe9, 0x09, 0x71, 0x28, 0x28, 0x3d, 0x94, 0x13, 0x07, 0xce, 0x1c, 0x90, 0xc7, 0x63, 0xaf, 0xbd,
+	0x6b, 0xef, 0xba, 0x01, 0xf5, 0x92, 0xec, 0xcc, 0xfb, 0xde, 0xdf, 0xf7, 0x66, 0xe6, 0x3d, 0x19,
+	0x94, 0xbb, 0x10, 0x32, 0xa3, 0xed, 0xd3, 0x2e, 0x76, 0x90, 0x6f, 0x74, 0xd7, 0x0c, 0x7e, 0x4b,
+	0x6f, 0xfb, 0x94, 0x53, 0xf5, 0x85, 0x40, 0xa4, 0x47, 0x22, 0xbd, 0xbb, 0xa6, 0x2d, 0x42, 0x0f,
+	0x13, 0x6a, 0x88, 0xbf, 0x21, 0x48, 0xab, 0xd8, 0x94, 0x79, 0x94, 0x19, 0x16, 0x64, 0xc8, 0xe8,
+	0xae, 0x59, 0x88, 0xc3, 0x35, 0xc3, 0xa6, 0x98, 0x48, 0xf9, 0xb2, 0x94, 0x7b, 0xcc, 0x0d, 0x8c,
+	0x7b, 0xcc, 0x95, 0x82, 0x72, 0x28, 0x68, 0x88, 0x95, 0x11, 0x2e, 0xa4, 0x68, 0xc9, 0xa5, 0x2e,
+	0x0d, 0xf7, 0x83, 0x5f, 0x72, 0xf7, 0x94, 0x4b, 0xa9, 0xdb, 0x42, 0x06, 0x6c, 0x63, 0x03, 0x12,
+	0x42, 0x39, 0xe4, 0x98, 0x92, 0x48, 0xa7, 0x2c, 0xa5, 0x62, 0x65, 0x75, 0x6e, 0x1a, 0x90, 0xf4,
+	0xa2, 0x10, 0x07, 0x45, 0x4e, 0xc7, 0x17, 0xba, 0x52, 0x5e, 0x1d, 0x94, 0x73, 0xec, 0x21, 0xc6,
+	0xa1, 0xd7, 0x8e, 0x00, 0xd8, 0xb2, 0x0d, 0x9b, 0xfa, 0xc8, 0xb0, 0x5b, 0x18, 0x11, 0x1e, 0x24,
+	0x12, 0xfe, 0x92, 0x00, 0x23, 0x00, 0xb4, 0xb0, 0xdb, 0xe4, 0xe1, 0x36, 0x33, 0x38, 0x22, 0x0e,
+	0xf2, 0x3d, 0x1c, 0x82, 0xfb, 0xab, 0xc8, 0x62, 0x42, 0xce, 0x7b, 0x6d, 0xc4, 0x0c, 0x14, 0x90,
+	0x4c, 0x6c, 0x14, 0x01, 0x86, 0xca, 0x12, 0xd7, 0x41, 0x00, 0x6a, 0xbf, 0x29, 0x60, 0xa9, 0xce,
+	0xdc, 0xab, 0x8c, 0x61, 0x97, 0x6c, 0x51, 0xc2, 0x3a, 0x1e, 0xf2, 0xdf, 0x43, 0x3d, 0xb5, 0x0a,
+	0xe6, 0x6c, 0xb9, 0x6c, 0x60, 0xa7, 0xa4, 0xac, 0x28, 0xab, 0xd3, 0x26, 0x88, 0xb6, 0x76, 0x1c,
+	0xf5, 0x32, 0x78, 0x3e, 0xb2, 0xd5, 0x80, 0x8e, 0xe3, 0x97, 0x26, 0x57, 0x94, 0xd5, 0xd9, 0x4d,
+	0xf5, 0xef, 0x47, 0xd5, 0x85, 0x1e, 0xf4, 0x5a, 0x1b, 0xb5, 0x60, 0x17, 0x31, 0x56, 0x33, 0xe7,
+	0x23, 0xe0, 0x55, 0xc7, 0xf1, 0xd5, 0xd3, 0x60, 0x3e, 0xb6, 0xbc, 0x87, 0x7a, 0xa5, 0xa9, 0x40,
+	0xcf, 0x8c, 0xbd, 0x05, 0xce, 0x2f, 0x82, 0x99, 0x20, 0x1e, 0xe4, 0x97, 0xa6, 0x85, 0xd1, 0xd2,
+	0xc3, 0x7b, 0x17, 0x96, 0x64, 0x6d, 0xaf, 0x86, 0x56, 0xaf, 0x73, 0x1f, 0x13, 0xd7, 0x94, 0xb8,
+	0x8d, 0xe3, 0xdf, 0xdc, 0xa9, 0x4e, 0xfc, 0x79, 0xa7, 0x3a, 0xf1, 0xd5, 0x93, 0xbb, 0xe7, 0xe4,
+	0x66, 0xad, 0x02, 0x4e, 0x65, 0xe5, 0x66, 0x22, 0xd6, 0xa6, 0x84, 0xa1, 0xda, 0x81, 0x02, 0x5e,
+	0xaa, 0x33, 0xf7, 0x7a, 0xc7, 0xf2, 0x30, 0x8f, 0x00, 0x75, 0xcc, 0x2c, 0xd4, 0x84, 0x5d, 0x4c,
+	0x3b, 0xbe, 0x7a, 0x09, 0xcc, 0x32, 0x21, 0xe5, 0xc8, 0x17, 0x1c, 0x8c, 0x8a, 0xa5, 0x0f, 0x55,
+	0x77, 0xc1, 0xbc, 0x97, 0xb0, 0x23, 0xb8, 0x99, 0x5b, 0x3f, 0xaf, 0x63, 0xcb, 0xd6, 0x93, 0x05,
+	0xd6, 0x13, 0x25, 0xed, 0xae, 0xe9, 0x49, 0xdf, 0x66, 0xca, 0xc2, 0x60, 0x3d, 0xa6, 0x06, 0xeb,
+	0xb1, 0x71, 0x32, 0xc9, 0x40, 0x3f, 0x94, 0xda, 0x59, 0xf0, 0xea, 0xc8, 0x1c, 0x63, 0x36, 0x7e,
+	0x99, 0xcc, 0x60, 0x63, 0x9b, 0x76, 0xac, 0x16, 0xba, 0x41, 0x39, 0x26, 0xee, 0xa1, 0xd9, 0x68,
+	0x80, 0x65, 0xa7, 0xd3, 0x6e, 0x61, 0x1b, 0x72, 0xd4, 0xe8, 0x52, 0x8e, 0x1a, 0xd1, 0x31, 0x95,
+	0xc4, 0x9c, 0x4d, 0xf2, 0x20, 0x0e, 0xb2, 0xbe, 0x1d, 0x29, 0xdc, 0xa0, 0x1c, 0xbd, 0x23, 0xe1,
+	0xe6, 0x09, 0x27, 0x6b, 0x5b, 0xfd, 0x04, 0x2c, 0x63, 0x72, 0xd3, 0x87, 0x76, 0x70, 0x1d, 0x1b,
+	0x56, 0x8b, 0xda, 0x7b, 0x8d, 0x26, 0x82, 0x0e, 0xf2, 0x05, 0x51, 0x73, 0xeb, 0x67, 0xc6, 0x31,
+	0xff, 0xae, 0x40, 0x9b, 0x27, 0xfa, 0x66, 0x36, 0x03, 0x2b, 0xe1, 0xf6, 0x20, 0xf9, 0xd3, 0xff,
+	0x89, 0xfc, 0x24, 0xa5, 0x31, 0xf9, 0xdf, 0x29, 0xe0, 0x58, 0x9d, 0xb9, 0x1f, 0xb4, 0x1d, 0xc8,
+	0xd1, 0x2e, 0xf4, 0xa1, 0xc7, 0x02, 0xba, 0x61, 0x87, 0x37, 0xa9, 0x8f, 0x79, 0x6f, 0x3c, 0xdd,
+	0x31, 0x54, 0xbd, 0x04, 0x66, 0xda, 0xc2, 0x82, 0x64, 0xb7, 0xa4, 0x0f, 0xbe, 0xc0, 0x7a, 0xe8,
+	0x61, 0x73, 0xfa, 0xfe, 0xa3, 0xea, 0x84, 0x29, 0xd1, 0x1b, 0x0b, 0x22, 0xf8, 0xd8, 0x4e, 0xad,
+	0x0c, 0x96, 0x07, 0x42, 0x8a, 0xc3, 0xfd, 0x1c, 0x2c, 0xd6, 0x99, 0x6b, 0x22, 0x8f, 0x76, 0x51,
+	0x94, 0xd7, 0xf8, 0x27, 0x23, 0x95, 0xd0, 0x64, 0xe1, 0x84, 0x86, 0x02, 0x7b, 0x11, 0x94, 0x87,
+	0xbc, 0xc7, 0xa1, 0xfd, 0x34, 0x29, 0x62, 0xdb, 0xf2, 0x11, 0xe4, 0xfd, 0xd8, 0x0e, 0x7b, 0x74,
+	0xcb, 0xe0, 0xa8, 0xdd, 0x84, 0x98, 0x04, 0x09, 0x89, 0x88, 0xcd, 0xe7, 0xc4, 0x7a, 0xc7, 0x51,
+	0xb7, 0xc1, 0x51, 0x0f, 0x71, 0xe8, 0x40, 0x0e, 0xe5, 0x29, 0xab, 0x0d, 0x13, 0x1d, 0xdf, 0x38,
+	0x89, 0x94, 0x94, 0xc7, 0x9a, 0x2a, 0x05, 0x65, 0x4c, 0x30, 0xc7, 0xb0, 0x85, 0x3f, 0x13, 0xdd,
+	0xa4, 0x21, 0xaa, 0x81, 0x38, 0xf2, 0x99, 0x38, 0x68, 0x73, 0xeb, 0xeb, 0xf9, 0x66, 0x77, 0x52,
+	0xaa, 0xbb, 0xb1, 0xa6, 0x59, 0xc2, 0x39, 0x12, 0x49, 0x66, 0xff, 0x88, 0x5e, 0x11, 0x64, 0xa6,
+	0xe9, 0x8a, 0xc8, 0x1c, 0x5b, 0xd2, 0xda, 0xed, 0x29, 0xc1, 0x76, 0x78, 0x48, 0x62, 0xb6, 0x75,
+	0x70, 0x84, 0xee, 0x93, 0x02, 0x4c, 0x87, 0xb0, 0x41, 0x37, 0x93, 0x43, 0x27, 0x67, 0x1b, 0x2c,
+	0x12, 0xb4, 0xdf, 0x10, 0xe8, 0x86, 0xec, 0x2b, 0x61, 0xe3, 0x18, 0x61, 0xfc, 0x18, 0x41, 0xfb,
+	0xef, 0x07, 0x1a, 0x72, 0x5b, 0x7d, 0x3b, 0x51, 0xb1, 0xe9, 0xa2, 0x15, 0x2b, 0x5a, 0xab, 0x23,
+	0xff, 0x7f, 0xad, 0xd4, 0x15, 0x30, 0x1f, 0xa4, 0x1d, 0x9f, 0xc0, 0x19, 0x71, 0x02, 0x01, 0x41,
+	0xfb, 0x5b, 0xe1, 0x21, 0xdc, 0x00, 0x41, 0x35, 0x43, 0x16, 0xe5, 0xb5, 0x48, 0x97, 0xa2, 0x7f,
+	0x2d, 0x14, 0xa0, 0x05, 0x4f, 0x11, 0x8a, 0xdf, 0xa1, 0x6b, 0x08, 0xb1, 0x5d, 0xe4, 0x8b, 0x77,
+	0xee, 0xd0, 0x6f, 0xcd, 0xd8, 0xca, 0x9d, 0x01, 0x33, 0xd0, 0xa3, 0x1d, 0xc2, 0x65, 0xb9, 0x16,
+	0x1e, 0xde, 0xbb, 0x00, 0xa4, 0xd5, 0x1d, 0xc2, 0x4d, 0x29, 0x1d, 0xba, 0xe3, 0xaf, 0x80, 0x5a,
+	0x7e, 0xb8, 0x71, 0x56, 0x3f, 0x2b, 0xe0, 0x64, 0x9d, 0xb9, 0xd7, 0x3a, 0xc4, 0x49, 0xe0, 0x76,
+	0x29, 0x6d, 0x25, 0x66, 0x08, 0xa5, 0xd8, 0x0c, 0x31, 0x3e, 0x97, 0x2b, 0xa9, 0x5c, 0xe6, 0xd6,
+	0xcb, 0xba, 0xb4, 0x17, 0x4c, 0xad, 0xba, 0x9c, 0x5a, 0xf5, 0x2d, 0x8a, 0xc9, 0xe6, 0x6c, 0x70,
+	0xcd, 0x7f, 0x78, 0x72, 0xf7, 0x9c, 0x12, 0x67, 0x98, 0x39, 0xa2, 0xac, 0x80, 0x4a, 0x76, 0xfc,
+	0x71, 0x8a, 0x7f, 0x85, 0x85, 0xfb, 0x10, 0xf3, 0xa6, 0xe3, 0xc3, 0xfd, 0x67, 0x90, 0x66, 0x33,
+	0x91, 0xe6, 0xd4, 0xe8, 0x34, 0xdf, 0x0a, 0xd2, 0xfc, 0xf1, 0xf7, 0xea, 0xaa, 0x8b, 0x79, 0xb3,
+	0x63, 0xe9, 0x36, 0xf5, 0xe4, 0x0c, 0x2e, 0xff, 0x5d, 0x60, 0xce, 0x5e, 0x38, 0x9a, 0x0a, 0x05,
+	0x56, 0x80, 0x92, 0xdb, 0x8a, 0x28, 0x7d, 0x4e, 0xc2, 0xf1, 0xd3, 0x64, 0xc7, 0x51, 0x2a, 0xe3,
+	0xa2, 0xbc, 0xf8, 0xb4, 0x51, 0x46, 0x01, 0xd6, 0xbe, 0x57, 0x44, 0x0f, 0xbc, 0xbe, 0x8f, 0x50,
+	0xfb, 0x19, 0x30, 0x7f, 0x12, 0xcc, 0x38, 0x88, 0x50, 0x8f, 0x09, 0xe6, 0x67, 0x4d, 0xb9, 0xca,
+	0xe6, 0xe9, 0x34, 0xa8, 0xe6, 0x84, 0x16, 0x71, 0xb4, 0xfe, 0xcf, 0x2c, 0x98, 0xaa, 0x33, 0x57,
+	0xdd, 0x03, 0x8b, 0xc3, 0x13, 0xfe, 0x99, 0xe1, 0xa7, 0x2a, 0x6b, 0x5a, 0xd6, 0xf4, 0x62, 0xb8,
+	0xb8, 0x30, 0x5f, 0x2b, 0x40, 0x1b, 0x31, 0x52, 0x1b, 0x99, 0xe6, 0xf2, 0x15, 0xb4, 0xcb, 0x4f,
+	0xa9, 0x30, 0x22, 0x90, 0xd4, 0x34, 0x5b, 0x24, 0x90, 0xa4, 0x42, 0xa1, 0x40, 0xb2, 0x86, 0x3b,
+	0xd5, 0x02, 0x0b, 0x03, 0xe3, 0xc8, 0xcb, 0x99, 0xa6, 0xd2, 0x20, 0xed, 0xf5, 0x02, 0xa0, 0xa4,
+	0x8f, 0x81, 0x26, 0x9c, 0xed, 0x23, 0x0d, 0xca, 0xf1, 0x91, 0xdd, 0x43, 0x02, 0x1f, 0x03, 0x23,
+	0x5f, 0xb6, 0x8f, 0x34, 0x28, 0xc7, 0x47, 0xf6, 0xf8, 0xa6, 0x7e, 0x0c, 0xe6, 0x53, 0x43, 0xf0,
+	0xe9, 0x11, 0x01, 0x86, 0x10, 0xed, 0xb5, 0xb1, 0x90, 0xd8, 0xfa, 0x17, 0x60, 0x39, 0xaf, 0x03,
+	0x9e, 0xcf, 0xae, 0x6e, 0x36, 0x5a, 0x7b, 0xf3, 0x69, 0xd0, 0xb1, 0xfb, 0x4f, 0xc1, 0xf1, 0xac,
+	0x56, 0xb5, 0x9a, 0x69, 0x2c, 0x03, 0xa9, 0x5d, 0x2c, 0x8a, 0x4c, 0x66, 0x9c, 0xd7, 0x3a, 0xb2,
+	0x33, 0xce, 0x41, 0xe7, 0x64, 0x3c, 0xee, 0x95, 0xe6, 0x60, 0x29, 0xf3, 0xf1, 0xcc, 0xae, 0x59,
+	0x16, 0x54, 0x5b, 0x2b, 0x0c, 0x8d, 0xbc, 0x6a, 0x47, 0xbe, 0x0c, 0xda, 0xcc, 0xe6, 0xce, 0xfd,
+	0x83, 0x8a, 0xf2, 0xe0, 0xa0, 0xa2, 0xfc, 0x71, 0x50, 0x51, 0xbe, 0x7d, 0x5c, 0x99, 0x78, 0xf0,
+	0xb8, 0x32, 0xf1, 0xeb, 0xe3, 0xca, 0xc4, 0x47, 0x46, 0xa2, 0x13, 0xc0, 0x56, 0x0b, 0x13, 0x0b,
+	0x73, 0x66, 0x88, 0x8f, 0x25, 0xb7, 0x8c, 0xf4, 0x37, 0x13, 0xd1, 0x16, 0xac, 0x19, 0xf1, 0xb9,
+	0xe4, 0x8d, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xf6, 0xdf, 0x3e, 0x6a, 0xe8, 0x12, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1941,10 +1941,10 @@ func (m *MsgRemoveConsumer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if len(m.Owner) > 0 {
-		i -= len(m.Owner)
-		copy(dAtA[i:], m.Owner)
-		i = encodeVarintTx(dAtA, i, uint64(len(m.Owner)))
+	if len(m.Authority) > 0 {
+		i -= len(m.Authority)
+		copy(dAtA[i:], m.Authority)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Authority)))
 		i--
 		dAtA[i] = 0x12
 	}
@@ -2587,7 +2587,7 @@ func (m *MsgRemoveConsumer) Size() (n int) {
 	if m.ConsumerId != 0 {
 		n += 1 + sovTx(uint64(m.ConsumerId))
 	}
-	l = len(m.Owner)
+	l = len(m.Authority)
 	if l > 0 {
 		n += 1 + l + sovTx(uint64(l))
 	}
@@ -3649,7 +3649,7 @@ func (m *MsgRemoveConsumer) Unmarshal(dAtA []byte) error {
 			}
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -3677,7 +3677,7 @@ func (m *MsgRemoveConsumer) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Owner = string(dAtA[iNdEx:postIndex])
+			m.Authority = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex