From 3f40fe6ddb61cb2d306bedb9ce24df0b9311d4e0 Mon Sep 17 00:00:00 2001 From: Julien Robert Date: Thu, 4 Jun 2026 14:06:59 +0200 Subject: [PATCH 1/4] refactor remove consumer to require gov authority on some operations --- proto/vaas/provider/v1/genesis.proto | 2 +- proto/vaas/provider/v1/tx.proto | 7 +- x/vaas/provider/client/cli/tx.go | 8 +- x/vaas/provider/keeper/msg_server.go | 63 ++++-- x/vaas/provider/keeper/msg_server_test.go | 244 ++++++++++++++++++++++ x/vaas/provider/types/events.go | 2 + x/vaas/provider/types/genesis.pb.go | 2 +- x/vaas/provider/types/msg.go | 7 +- x/vaas/provider/types/tx.pb.go | 167 +++++++-------- x/vaas/types/wire.pb.go | 45 ++-- 10 files changed, 417 insertions(+), 130 deletions(-) diff --git a/proto/vaas/provider/v1/genesis.proto b/proto/vaas/provider/v1/genesis.proto index bce1db8..b76459a 100644 --- a/proto/vaas/provider/v1/genesis.proto +++ b/proto/vaas/provider/v1/genesis.proto @@ -64,7 +64,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/tx.proto b/proto/vaas/provider/v1/tx.proto index 8cef12a..3ce7c6f 100644 --- a/proto/vaas/provider/v1/tx.proto +++ b/proto/vaas/provider/v1/tx.proto @@ -101,13 +101,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 6b71f77..8ef73d9 100644 --- a/x/vaas/provider/client/cli/tx.go +++ b/x/vaas/provider/client/cli/tx.go @@ -388,9 +388,9 @@ If one of the fields is missing, it will be set to its zero value. func NewRemoveConsumerCmd() *cobra.Command { cmd := &cobra.Command{ Use: "remove-consumer [consumer-id]", - Short: "remove a consumer chain", + Short: "remove a consumer chain (gov authority only)", Long: strings.TrimSpace( - fmt.Sprintf(`Removes (and stops) a consumer chain. Note that only the owner of the chain can remove it. + fmt.Sprintf(`Removes (and stops) a consumer chain. Only the governance authority can remove a consumer chain. Example: %s tx provider remove-consumer [consumer-id] `, version.AppName)), @@ -407,13 +407,13 @@ Example: } txf = txf.WithTxConfig(clientCtx.TxConfig).WithAccountRetriever(clientCtx.AccountRetriever) - owner := clientCtx.GetFromAddress().String() + authority := clientCtx.GetFromAddress().String() consumerId, err := parseConsumerIdArg(args[0]) if err != nil { return err } - msg, err := types.NewMsgRemoveConsumer(owner, consumerId) + msg, err := types.NewMsgRemoveConsumer(authority, consumerId) if err != nil { return err } diff --git a/x/vaas/provider/keeper/msg_server.go b/x/vaas/provider/keeper/msg_server.go index 5e594a3..cfcb2e2 100644 --- a/x/vaas/provider/keeper/msg_server.go +++ b/x/vaas/provider/keeper/msg_server.go @@ -264,6 +264,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 @@ -272,10 +286,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 @@ -330,6 +340,25 @@ 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. + // Chain-id, initialization parameters, and owner transfer 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; only metadata updates are allowed after launch") + } + if strings.TrimSpace(msg.NewOwnerAddress) != "" { + return &resp, errorsmod.Wrapf(types.ErrInvalidPhase, + "cannot transfer ownership of a launched chain; only metadata updates are allowed after launch") + } + if msg.InitializationParameters != nil { + return &resp, errorsmod.Wrapf(types.ErrInvalidPhase, + "cannot update initialization parameters of a launched chain; only metadata updates are allowed after launch") + } + } + // 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 { @@ -414,6 +443,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()) @@ -460,27 +498,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, @@ -501,7 +536,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 6e18faa..69a0b7e 100644 --- a/x/vaas/provider/keeper/msg_server_test.go +++ b/x/vaas/provider/keeper/msg_server_test.go @@ -628,3 +628,247 @@ func TestUpdateParams_ReconcilesFeesPerBlockOverrides(t *testing.T) { require.NoError(t, err) 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 fail + _, err = msgServer.UpdateConsumer(ctx, + &providertypes.MsgUpdateConsumer{ + Owner: "submitter", + ConsumerId: consumerId, + NewOwnerAddress: "cosmos1dkas8mu4kyhl5jrh4nzvm65qz588hy9qcz08la", + }) + require.Error(t, err) + require.ErrorIs(t, err, providertypes.ErrInvalidPhase) + + // initialization parameters update should fail + _, err = msgServer.UpdateConsumer(ctx, + &providertypes.MsgUpdateConsumer{ + Owner: "submitter", + 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") +} diff --git a/x/vaas/provider/types/events.go b/x/vaas/provider/types/events.go index 656708e..cada2f4 100644 --- a/x/vaas/provider/types/events.go +++ b/x/vaas/provider/types/events.go @@ -24,5 +24,7 @@ const ( AttributeConsumerOwner = "consumer_owner" AttributeConsumerSpawnTime = "consumer_spawn_time" AttributeConsumerPhase = "consumer_phase" + AttributeConsumerBinaryHash = "consumer_binary_hash" + AttributeConsumerGenesisHash = "consumer_genesis_hash" AttributeKeyAmount = "amount" ) diff --git a/x/vaas/provider/types/genesis.pb.go b/x/vaas/provider/types/genesis.pb.go index fd70edf..794bb6c 100644 --- a/x/vaas/provider/types/genesis.pb.go +++ b/x/vaas/provider/types/genesis.pb.go @@ -160,7 +160,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 3a639fa..3c68ef0 100644 --- a/x/vaas/provider/types/msg.go +++ b/x/vaas/provider/types/msg.go @@ -279,15 +279,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/tx.pb.go b/x/vaas/provider/types/tx.pb.go index 451e69a..b11a968 100644 --- a/x/vaas/provider/types/tx.pb.go +++ b/x/vaas/provider/types/tx.pb.go @@ -374,11 +374,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{} } @@ -421,9 +422,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 "" } @@ -842,79 +843,79 @@ func init() { func init() { proto.RegisterFile("vaas/provider/v1/tx.proto", fileDescriptor_a07778b1d094765c) } var fileDescriptor_a07778b1d094765c = []byte{ - // 1151 bytes of a gzipped FileDescriptorProto + // 1150 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x4d, 0x6f, 0xdc, 0x44, - 0x18, 0x5e, 0xe7, 0xab, 0xed, 0x24, 0xa4, 0xc4, 0xa4, 0x64, 0x77, 0x29, 0xbb, 0xa9, 0x81, 0xb4, - 0x94, 0xd6, 0x26, 0x01, 0xb5, 0x52, 0x84, 0x90, 0xf2, 0x01, 0x22, 0x42, 0x2b, 0x22, 0x57, 0xf4, - 0x80, 0x10, 0xd6, 0xd8, 0x9e, 0x7a, 0x47, 0x59, 0xcf, 0xac, 0x3c, 0xb3, 0x9b, 0x2e, 0x12, 0x12, - 0xe2, 0x80, 0xe0, 0x06, 0x12, 0x3f, 0xa0, 0x7f, 0x00, 0xa9, 0x87, 0xfe, 0x88, 0x1e, 0x4b, 0x4f, - 0x88, 0x43, 0x85, 0x92, 0x43, 0x39, 0xf3, 0x0b, 0xd0, 0x8c, 0xc7, 0x5e, 0xaf, 0xd7, 0xfb, 0xd1, - 0xd0, 0xcb, 0x6a, 0x67, 0xde, 0xe7, 0xfd, 0x98, 0xe7, 0x79, 0xe7, 0xc3, 0xa0, 0xd2, 0x85, 0x90, - 0x59, 0xed, 0x88, 0x76, 0xb1, 0x8f, 0x22, 0xab, 0xbb, 0x69, 0xf1, 0xfb, 0x66, 0x3b, 0xa2, 0x9c, - 0xea, 0xaf, 0x0a, 0x93, 0x99, 0x98, 0xcc, 0xee, 0x66, 0x75, 0x05, 0x86, 0x98, 0x50, 0x4b, 0xfe, - 0xc6, 0xa0, 0xea, 0x9a, 0x47, 0x59, 0x48, 0x99, 0x15, 0xb2, 0x40, 0x38, 0x87, 0x2c, 0x50, 0x86, - 0x4a, 0x6c, 0x70, 0xe4, 0xc8, 0x8a, 0x07, 0xca, 0xb4, 0x1a, 0xd0, 0x80, 0xc6, 0xf3, 0xe2, 0x9f, - 0x9a, 0xbd, 0x1c, 0x50, 0x1a, 0xb4, 0x90, 0x05, 0xdb, 0xd8, 0x82, 0x84, 0x50, 0x0e, 0x39, 0xa6, - 0x24, 0xf1, 0xa9, 0x28, 0xab, 0x1c, 0xb9, 0x9d, 0x7b, 0x16, 0x24, 0x3d, 0x65, 0xaa, 0xe5, 0x4d, - 0x7e, 0x27, 0x92, 0xbe, 0xca, 0x5e, 0xcf, 0xdb, 0x39, 0x0e, 0x11, 0xe3, 0x30, 0x6c, 0x27, 0x00, - 0xec, 0x7a, 0x96, 0x47, 0x23, 0x64, 0x79, 0x2d, 0x8c, 0x08, 0x17, 0x0b, 0x89, 0xff, 0x29, 0x80, - 0x25, 0x00, 0x2d, 0x1c, 0x34, 0x79, 0x3c, 0xcd, 0x2c, 0x8e, 0x88, 0x8f, 0xa2, 0x10, 0xc7, 0xe0, - 0xfe, 0x28, 0x89, 0x98, 0xb1, 0xf3, 0x5e, 0x1b, 0x31, 0x0b, 0x09, 0x12, 0x89, 0x87, 0x12, 0xc0, - 0x10, 0xed, 0x29, 0xcf, 0x12, 0x60, 0xfc, 0xa5, 0x81, 0xd5, 0x06, 0x0b, 0x76, 0x18, 0xc3, 0x01, - 0xd9, 0xa3, 0x84, 0x75, 0x42, 0x14, 0x7d, 0x8e, 0x7a, 0x7a, 0x1d, 0x2c, 0x7a, 0x6a, 0xe8, 0x60, - 0xbf, 0xac, 0xad, 0x6b, 0xd7, 0xe6, 0x6c, 0x90, 0x4c, 0x1d, 0xf8, 0xfa, 0x6d, 0xf0, 0x4a, 0x12, - 0xcb, 0x81, 0xbe, 0x1f, 0x95, 0x67, 0xd6, 0xb5, 0x6b, 0x17, 0x76, 0xf5, 0x7f, 0x9f, 0xd5, 0x97, - 0x7b, 0x30, 0x6c, 0x6d, 0x1b, 0x62, 0x16, 0x31, 0x66, 0xd8, 0x4b, 0x09, 0x70, 0xc7, 0xf7, 0x23, - 0xfd, 0x0a, 0x58, 0x4a, 0x23, 0x1f, 0xa1, 0x5e, 0x79, 0x56, 0xf8, 0xd9, 0x69, 0x36, 0x91, 0xfc, - 0x7d, 0xb0, 0x20, 0xea, 0x41, 0x51, 0x79, 0x4e, 0x06, 0x2d, 0x3f, 0x7d, 0x74, 0x73, 0x55, 0x69, - 0xbb, 0x13, 0x47, 0xbd, 0xc3, 0x23, 0x4c, 0x02, 0x5b, 0xe1, 0xb6, 0x5f, 0xfb, 0xe9, 0x41, 0xbd, - 0xf4, 0xcf, 0x83, 0x7a, 0xe9, 0x87, 0xe7, 0x0f, 0xaf, 0xab, 0x49, 0xa3, 0x06, 0x2e, 0x17, 0xad, - 0xcd, 0x46, 0xac, 0x4d, 0x09, 0x43, 0xc6, 0x89, 0x06, 0xde, 0x6c, 0xb0, 0xe0, 0x4e, 0xc7, 0x0d, - 0x31, 0x4f, 0x00, 0x0d, 0xcc, 0x5c, 0xd4, 0x84, 0x5d, 0x4c, 0x3b, 0x91, 0x7e, 0x0b, 0x5c, 0x60, - 0xd2, 0xca, 0x51, 0x24, 0x39, 0x18, 0x57, 0x4b, 0x1f, 0xaa, 0x1f, 0x82, 0xa5, 0x30, 0x13, 0x47, - 0x72, 0xb3, 0xb8, 0x75, 0xc3, 0xc4, 0xae, 0x67, 0x66, 0x05, 0x36, 0x33, 0x92, 0x76, 0x37, 0xcd, - 0x6c, 0x6e, 0x7b, 0x20, 0x42, 0x5e, 0x8f, 0xd9, 0xbc, 0x1e, 0xdb, 0xaf, 0x67, 0x19, 0xe8, 0x97, - 0x62, 0x5c, 0x05, 0xef, 0x8c, 0x5d, 0x63, 0xca, 0xc6, 0x1f, 0x33, 0x05, 0x6c, 0xec, 0xd3, 0x8e, - 0xdb, 0x42, 0x77, 0x29, 0xc7, 0x24, 0x38, 0x33, 0x1b, 0x0e, 0x58, 0xf3, 0x3b, 0xed, 0x16, 0xf6, - 0x20, 0x47, 0x4e, 0x97, 0x72, 0xe4, 0x24, 0x6d, 0xaa, 0x88, 0xb9, 0x9a, 0xe5, 0x41, 0x36, 0xb2, - 0xb9, 0x9f, 0x38, 0xdc, 0xa5, 0x1c, 0x7d, 0xa2, 0xe0, 0xf6, 0x25, 0xbf, 0x68, 0x5a, 0xff, 0x06, - 0xac, 0x61, 0x72, 0x2f, 0x82, 0x9e, 0xd8, 0x8e, 0x8e, 0xdb, 0xa2, 0xde, 0x91, 0xd3, 0x44, 0xd0, - 0x47, 0x91, 0x24, 0x6a, 0x71, 0x6b, 0x63, 0x12, 0xf3, 0x9f, 0x49, 0xb4, 0x7d, 0xa9, 0x1f, 0x66, - 0x57, 0x44, 0x89, 0xa7, 0xf3, 0xe4, 0xcf, 0xfd, 0x2f, 0xf2, 0xb3, 0x94, 0xa6, 0xe4, 0xff, 0xaa, - 0x81, 0x8b, 0x0d, 0x16, 0x7c, 0xd9, 0xf6, 0x21, 0x47, 0x87, 0x30, 0x82, 0x21, 0x13, 0x74, 0xc3, - 0x0e, 0x6f, 0xd2, 0x08, 0xf3, 0xde, 0x64, 0xba, 0x53, 0xa8, 0x7e, 0x0b, 0x2c, 0xb4, 0x65, 0x04, - 0xc5, 0x6e, 0xd9, 0xcc, 0x9f, 0xb0, 0x66, 0x9c, 0x61, 0x77, 0xee, 0xf1, 0xb3, 0x7a, 0xc9, 0x56, - 0xe8, 0xed, 0x65, 0x59, 0x7c, 0x1a, 0xc7, 0xa8, 0x80, 0xb5, 0x5c, 0x49, 0x69, 0xb9, 0x6d, 0xb0, - 0xd2, 0x60, 0x81, 0x8d, 0x42, 0xda, 0x45, 0xc9, 0xba, 0x26, 0x1f, 0x19, 0x26, 0x98, 0xa7, 0xc7, - 0x62, 0x57, 0xcf, 0x4c, 0x58, 0x4c, 0x0c, 0xdb, 0x06, 0xa2, 0xa0, 0xf8, 0xbf, 0xf1, 0x06, 0xa8, - 0x0c, 0x65, 0x4c, 0xcb, 0xf9, 0x7d, 0x46, 0xd6, 0xb3, 0x17, 0x21, 0xc8, 0xfb, 0xf5, 0x9c, 0xb5, - 0x5d, 0x2b, 0xe0, 0xbc, 0xd7, 0x84, 0x98, 0x88, 0x45, 0xc8, 0x4a, 0xed, 0x73, 0x72, 0x7c, 0xe0, - 0xeb, 0xfb, 0xe0, 0x7c, 0x88, 0x38, 0xf4, 0x21, 0x87, 0xaa, 0xb3, 0x8c, 0x61, 0x72, 0xd3, 0x5d, - 0xa6, 0x90, 0x8a, 0xe6, 0xd4, 0x53, 0xa7, 0xa0, 0x82, 0x09, 0xe6, 0x18, 0xb6, 0xf0, 0xb7, 0xf2, - 0x06, 0x71, 0xa4, 0x02, 0x88, 0xa3, 0x88, 0xc9, 0xe6, 0x5a, 0xdc, 0xda, 0x1a, 0x1d, 0xf6, 0x60, - 0xc0, 0xf5, 0x30, 0xf5, 0xb4, 0xcb, 0x78, 0x84, 0x45, 0x29, 0xdb, 0x6f, 0xcb, 0x8f, 0x24, 0x99, - 0x83, 0x74, 0x25, 0x64, 0x4e, 0x94, 0xd1, 0xf8, 0x79, 0x56, 0xb2, 0x1d, 0x37, 0x46, 0xca, 0x76, - 0x2a, 0xae, 0x36, 0x95, 0xb8, 0xf9, 0x34, 0x33, 0x43, 0xdd, 0xb2, 0x0f, 0x56, 0x08, 0x3a, 0x76, - 0x24, 0xda, 0x51, 0x77, 0x49, 0x7c, 0x59, 0x8c, 0x09, 0x7e, 0x91, 0xa0, 0xe3, 0x2f, 0x84, 0x87, - 0x9a, 0xd6, 0x3f, 0xce, 0x28, 0x36, 0x37, 0xad, 0x62, 0xd3, 0x6a, 0x35, 0xff, 0xf2, 0xb5, 0xd2, - 0xd7, 0xc1, 0x92, 0x58, 0x76, 0xda, 0x81, 0x0b, 0xb2, 0x03, 0x01, 0x41, 0xc7, 0x7b, 0x71, 0x13, - 0x16, 0x6c, 0x8b, 0x41, 0x29, 0xfa, 0xdb, 0x42, 0x03, 0x55, 0x71, 0xfc, 0xa0, 0xf4, 0xec, 0xf9, - 0x14, 0x21, 0x76, 0x88, 0x22, 0x79, 0xb6, 0x9d, 0xf9, 0x7c, 0x99, 0xa8, 0xdc, 0x06, 0x58, 0x80, - 0x21, 0xed, 0x10, 0xae, 0xe4, 0x5a, 0x7e, 0xfa, 0xe8, 0x26, 0x50, 0x51, 0x0f, 0x08, 0xb7, 0x95, - 0x75, 0xe8, 0xc0, 0x79, 0x1b, 0x18, 0xa3, 0xcb, 0x4d, 0x56, 0xb5, 0xf5, 0xdb, 0x39, 0x30, 0xdb, - 0x60, 0x81, 0x7e, 0x04, 0x56, 0x86, 0x9f, 0x2d, 0x1b, 0xc3, 0x5a, 0x14, 0x3d, 0x01, 0xaa, 0xe6, - 0x74, 0xb8, 0x74, 0x53, 0xfc, 0xa8, 0x81, 0xea, 0x98, 0x77, 0x82, 0x55, 0x18, 0x6e, 0xb4, 0x43, - 0xf5, 0xf6, 0x0b, 0x3a, 0x8c, 0x29, 0x64, 0xe0, 0x8a, 0x9e, 0xa6, 0x90, 0xac, 0xc3, 0x54, 0x85, - 0x14, 0xdd, 0x58, 0xba, 0x0b, 0x96, 0x73, 0xe7, 0xed, 0x5b, 0x85, 0xa1, 0x06, 0x41, 0xd5, 0xf7, - 0xa6, 0x00, 0x65, 0x73, 0xe4, 0x4e, 0x99, 0xe2, 0x1c, 0x83, 0xa0, 0x11, 0x39, 0x8a, 0x37, 0x89, - 0xc8, 0x91, 0xbb, 0xc7, 0x8a, 0x73, 0x0c, 0x82, 0x46, 0xe4, 0x28, 0xbe, 0x9f, 0xf4, 0xaf, 0xc1, - 0xd2, 0xc0, 0xcd, 0x7e, 0x65, 0x4c, 0x81, 0x31, 0xa4, 0xfa, 0xee, 0x44, 0x48, 0x1a, 0xfd, 0x3b, - 0xb0, 0x36, 0x6a, 0x8b, 0xdf, 0x28, 0x56, 0xb7, 0x18, 0x5d, 0xfd, 0xf0, 0x45, 0xd0, 0x49, 0xfa, - 0xea, 0xfc, 0xf7, 0xcf, 0x1f, 0x5e, 0xd7, 0x76, 0x0f, 0x1e, 0x9f, 0xd4, 0xb4, 0x27, 0x27, 0x35, - 0xed, 0xef, 0x93, 0x9a, 0xf6, 0xcb, 0x69, 0xad, 0xf4, 0xe4, 0xb4, 0x56, 0xfa, 0xf3, 0xb4, 0x56, - 0xfa, 0xca, 0x0a, 0x30, 0x6f, 0x76, 0x5c, 0xd3, 0xa3, 0xa1, 0x05, 0x5b, 0x2d, 0x4c, 0x5c, 0xcc, - 0x99, 0x25, 0xbf, 0x4c, 0xee, 0x5b, 0x83, 0x1f, 0x28, 0xf2, 0xed, 0xe7, 0x2e, 0xc8, 0x6f, 0x93, - 0x0f, 0xfe, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xc6, 0x51, 0x75, 0x12, 0x35, 0x0e, 0x00, 0x00, + 0x18, 0x5e, 0xe7, 0xab, 0xed, 0x24, 0xa4, 0xc4, 0xa4, 0x64, 0x77, 0x29, 0xbb, 0xe9, 0x02, 0x69, + 0x29, 0xad, 0x4d, 0x02, 0x6a, 0xa5, 0x08, 0x21, 0xe5, 0x03, 0x44, 0x84, 0x56, 0x44, 0xae, 0xe8, + 0x01, 0x21, 0xac, 0xb1, 0x3d, 0xf5, 0x8e, 0xb2, 0x9e, 0x59, 0xcd, 0xcc, 0x6e, 0xba, 0x08, 0x24, + 0xc4, 0x01, 0xc1, 0x0d, 0x24, 0x7e, 0x40, 0xff, 0x00, 0x52, 0x0f, 0xfd, 0x11, 0x3d, 0x96, 0x9e, + 0x10, 0x87, 0x0a, 0x25, 0x87, 0x72, 0xe6, 0x17, 0x20, 0x8f, 0xc7, 0x5e, 0xdb, 0xeb, 0xfd, 0x68, + 0xe0, 0xb2, 0xda, 0x79, 0xdf, 0xe7, 0xfd, 0x7a, 0xde, 0x77, 0x3e, 0x0c, 0x2a, 0x3d, 0x08, 0xb9, + 0xd9, 0x61, 0xb4, 0x87, 0x3d, 0xc4, 0xcc, 0xde, 0xa6, 0x29, 0xee, 0x1b, 0x1d, 0x46, 0x05, 0xd5, + 0x5f, 0x0e, 0x55, 0x46, 0xac, 0x32, 0x7a, 0x9b, 0xd5, 0x15, 0x18, 0x60, 0x42, 0x4d, 0xf9, 0x1b, + 0x81, 0xaa, 0x6b, 0x2e, 0xe5, 0x01, 0xe5, 0x66, 0xc0, 0xfd, 0xd0, 0x38, 0xe0, 0xbe, 0x52, 0x54, + 0x22, 0x85, 0x2d, 0x57, 0x66, 0xb4, 0x50, 0xaa, 0x55, 0x9f, 0xfa, 0x34, 0x92, 0x87, 0xff, 0x94, + 0xf4, 0xb2, 0x4f, 0xa9, 0xdf, 0x46, 0x26, 0xec, 0x60, 0x13, 0x12, 0x42, 0x05, 0x14, 0x98, 0x92, + 0xd8, 0xa6, 0xa2, 0xb4, 0x72, 0xe5, 0x74, 0xef, 0x99, 0x90, 0xf4, 0x95, 0xaa, 0x96, 0x57, 0x79, + 0x5d, 0x26, 0x6d, 0x95, 0xbe, 0x9e, 0xd7, 0x0b, 0x1c, 0x20, 0x2e, 0x60, 0xd0, 0x89, 0x01, 0xd8, + 0x71, 0x4d, 0x97, 0x32, 0x64, 0xba, 0x6d, 0x8c, 0x88, 0x08, 0x0b, 0x89, 0xfe, 0x29, 0x80, 0x19, + 0x02, 0xda, 0xd8, 0x6f, 0x89, 0x48, 0xcc, 0x4d, 0x81, 0x88, 0x87, 0x58, 0x80, 0x23, 0xf0, 0x60, + 0x15, 0x7b, 0x4c, 0xe9, 0x45, 0xbf, 0x83, 0xb8, 0x89, 0x42, 0x12, 0x89, 0x8b, 0x62, 0xc0, 0x10, + 0xed, 0x09, 0xcf, 0x12, 0xd0, 0xf8, 0x53, 0x03, 0xab, 0x4d, 0xee, 0xef, 0x70, 0x8e, 0x7d, 0xb2, + 0x47, 0x09, 0xef, 0x06, 0x88, 0x7d, 0x8a, 0xfa, 0x7a, 0x1d, 0x2c, 0xba, 0x6a, 0x69, 0x63, 0xaf, + 0xac, 0xad, 0x6b, 0xd7, 0xe6, 0x2c, 0x10, 0x8b, 0x0e, 0x3c, 0xfd, 0x36, 0x78, 0x29, 0xf6, 0x65, + 0x43, 0xcf, 0x63, 0xe5, 0x99, 0x75, 0xed, 0xda, 0x85, 0x5d, 0xfd, 0x9f, 0x67, 0xf5, 0xe5, 0x3e, + 0x0c, 0xda, 0xdb, 0x8d, 0x50, 0x8a, 0x38, 0x6f, 0x58, 0x4b, 0x31, 0x70, 0xc7, 0xf3, 0x98, 0x7e, + 0x05, 0x2c, 0x25, 0x9e, 0x8f, 0x50, 0xbf, 0x3c, 0x1b, 0xda, 0x59, 0x49, 0xb4, 0x30, 0xf8, 0xbb, + 0x60, 0x21, 0xcc, 0x07, 0xb1, 0xf2, 0x9c, 0x74, 0x5a, 0x7e, 0xfa, 0xe8, 0xe6, 0xaa, 0xea, 0xed, + 0x4e, 0xe4, 0xf5, 0x8e, 0x60, 0x98, 0xf8, 0x96, 0xc2, 0x6d, 0xbf, 0xf2, 0xe3, 0x83, 0x7a, 0xe9, + 0xef, 0x07, 0xf5, 0xd2, 0xf7, 0xcf, 0x1f, 0x5e, 0x57, 0xc2, 0x46, 0x0d, 0x5c, 0x2e, 0xaa, 0xcd, + 0x42, 0xbc, 0x43, 0x09, 0x47, 0x8d, 0x13, 0x0d, 0xbc, 0xde, 0xe4, 0xfe, 0x9d, 0xae, 0x13, 0x60, + 0x11, 0x03, 0x9a, 0x98, 0x3b, 0xa8, 0x05, 0x7b, 0x98, 0x76, 0x99, 0x7e, 0x0b, 0x5c, 0xe0, 0x52, + 0x2b, 0x10, 0x93, 0x1c, 0x8c, 0xcb, 0x65, 0x00, 0xd5, 0x0f, 0xc1, 0x52, 0x90, 0xf2, 0x23, 0xb9, + 0x59, 0xdc, 0xba, 0x61, 0x60, 0xc7, 0x35, 0xd2, 0x0d, 0x36, 0x52, 0x2d, 0xed, 0x6d, 0x1a, 0xe9, + 0xd8, 0x56, 0xc6, 0x43, 0xbe, 0x1f, 0xb3, 0xf9, 0x7e, 0x6c, 0xbf, 0x9a, 0x66, 0x60, 0x90, 0x4a, + 0xe3, 0x2a, 0x78, 0x6b, 0x6c, 0x8d, 0x09, 0x1b, 0xbf, 0xcf, 0x14, 0xb0, 0xb1, 0x4f, 0xbb, 0x4e, + 0x1b, 0xdd, 0xa5, 0x02, 0x13, 0xff, 0xcc, 0x6c, 0xd8, 0x60, 0xcd, 0xeb, 0x76, 0xda, 0xd8, 0x85, + 0x02, 0xd9, 0x3d, 0x2a, 0x90, 0x1d, 0x8f, 0xa9, 0x22, 0xe6, 0x6a, 0x9a, 0x07, 0x39, 0xc8, 0xc6, + 0x7e, 0x6c, 0x70, 0x97, 0x0a, 0xf4, 0x91, 0x82, 0x5b, 0x97, 0xbc, 0x22, 0xb1, 0xfe, 0x15, 0x58, + 0xc3, 0xe4, 0x1e, 0x83, 0x6e, 0xb8, 0x1d, 0x6d, 0xa7, 0x4d, 0xdd, 0x23, 0xbb, 0x85, 0xa0, 0x87, + 0x98, 0x24, 0x6a, 0x71, 0x6b, 0x63, 0x12, 0xf3, 0x9f, 0x48, 0xb4, 0x75, 0x69, 0xe0, 0x66, 0x37, + 0xf4, 0x12, 0x89, 0xf3, 0xe4, 0xcf, 0xfd, 0x27, 0xf2, 0xd3, 0x94, 0x26, 0xe4, 0xff, 0xa2, 0x81, + 0x8b, 0x4d, 0xee, 0x7f, 0xde, 0xf1, 0xa0, 0x40, 0x87, 0x90, 0xc1, 0x80, 0x87, 0x74, 0xc3, 0xae, + 0x68, 0x51, 0x86, 0x45, 0x7f, 0x32, 0xdd, 0x09, 0x54, 0xbf, 0x05, 0x16, 0x3a, 0xd2, 0x83, 0x62, + 0xb7, 0x6c, 0xe4, 0x4f, 0x58, 0x23, 0x8a, 0xb0, 0x3b, 0xf7, 0xf8, 0x59, 0xbd, 0x64, 0x29, 0xf4, + 0xf6, 0xb2, 0x4c, 0x3e, 0xf1, 0xd3, 0xa8, 0x80, 0xb5, 0x5c, 0x4a, 0x49, 0xba, 0xdf, 0x80, 0x95, + 0x26, 0xf7, 0x2d, 0x14, 0xd0, 0x1e, 0x8a, 0xeb, 0x9a, 0x7c, 0x64, 0x64, 0x0a, 0x9a, 0x99, 0xba, + 0xa0, 0xa1, 0xc4, 0x5e, 0x03, 0x95, 0xa1, 0xe8, 0x49, 0x6a, 0xbf, 0xcd, 0xc8, 0xdc, 0xf6, 0x18, + 0x82, 0x62, 0x90, 0xdb, 0x59, 0x47, 0xb7, 0x02, 0xce, 0xbb, 0x2d, 0x88, 0x49, 0x58, 0x90, 0xcc, + 0xd8, 0x3a, 0x27, 0xd7, 0x07, 0x9e, 0xbe, 0x0f, 0xce, 0x07, 0x48, 0x40, 0x0f, 0x0a, 0xa8, 0xa6, + 0xac, 0x31, 0x4c, 0x74, 0xb2, 0xe3, 0x14, 0x52, 0x51, 0x9e, 0x58, 0xea, 0x14, 0x54, 0x30, 0xc1, + 0x02, 0xc3, 0x36, 0xfe, 0x5a, 0xde, 0x26, 0xb6, 0xec, 0x06, 0x12, 0x88, 0x71, 0x39, 0x68, 0x8b, + 0x5b, 0x5b, 0xa3, 0xdd, 0x1e, 0x64, 0x4c, 0x0f, 0x13, 0x4b, 0xab, 0x8c, 0x47, 0x68, 0x14, 0x99, + 0x83, 0x11, 0xfd, 0x40, 0x92, 0x99, 0xa5, 0x2b, 0x26, 0x73, 0x62, 0x4b, 0x1b, 0x3f, 0xcd, 0x4a, + 0xb6, 0xa3, 0x21, 0x49, 0xd8, 0x36, 0xc0, 0x3c, 0x3d, 0x26, 0x53, 0x30, 0x1d, 0xc1, 0xf2, 0x61, + 0x66, 0x86, 0x26, 0x67, 0x1f, 0xac, 0x10, 0x74, 0x6c, 0x4b, 0xb4, 0xad, 0xee, 0x95, 0xe8, 0xe2, + 0x18, 0xe3, 0xfc, 0x22, 0x41, 0xc7, 0x9f, 0x85, 0x16, 0x4a, 0xac, 0x7f, 0x98, 0xea, 0xd8, 0xdc, + 0xb4, 0x1d, 0x9b, 0xb6, 0x57, 0xf3, 0xff, 0x7f, 0xaf, 0xf4, 0x75, 0xb0, 0x14, 0x96, 0x9d, 0x4c, + 0xe0, 0x82, 0x9c, 0x40, 0x40, 0xd0, 0xf1, 0x5e, 0x34, 0x84, 0xdb, 0x20, 0xec, 0x66, 0xc4, 0xa2, + 0xda, 0x16, 0xd9, 0x56, 0x0c, 0xb6, 0x85, 0x06, 0xaa, 0xe1, 0x51, 0x84, 0x92, 0x73, 0xe8, 0x63, + 0x84, 0xf8, 0x21, 0x62, 0xf2, 0x9c, 0x3b, 0xf3, 0x59, 0x33, 0xb1, 0x73, 0x1b, 0x60, 0x01, 0x06, + 0xb4, 0x4b, 0x84, 0x6a, 0xd7, 0xf2, 0xd3, 0x47, 0x37, 0x81, 0xf2, 0x7a, 0x40, 0x84, 0xa5, 0xb4, + 0x43, 0x7b, 0xfc, 0x4d, 0xd0, 0x18, 0x9d, 0x6e, 0x5c, 0xd5, 0xd6, 0xaf, 0xe7, 0xc0, 0x6c, 0x93, + 0xfb, 0xfa, 0x11, 0x58, 0x19, 0x7e, 0xc2, 0x6c, 0x0c, 0xf7, 0xa2, 0xe8, 0x39, 0x50, 0x35, 0xa6, + 0xc3, 0x25, 0x9b, 0xe2, 0x07, 0x0d, 0x54, 0xc7, 0xbc, 0x19, 0xcc, 0x42, 0x77, 0xa3, 0x0d, 0xaa, + 0xb7, 0x5f, 0xd0, 0x60, 0x4c, 0x22, 0x99, 0xeb, 0x7a, 0x9a, 0x44, 0xd2, 0x06, 0x53, 0x25, 0x52, + 0x74, 0x7b, 0xe9, 0x0e, 0x58, 0xce, 0x9d, 0xb7, 0x6f, 0x14, 0xba, 0xca, 0x82, 0xaa, 0xef, 0x4c, + 0x01, 0x4a, 0xc7, 0xc8, 0x9d, 0x32, 0xc5, 0x31, 0xb2, 0xa0, 0x11, 0x31, 0x8a, 0x37, 0x49, 0x18, + 0x23, 0x77, 0xa7, 0x15, 0xc7, 0xc8, 0x82, 0x46, 0xc4, 0x28, 0xbe, 0x9f, 0xf4, 0x2f, 0xc1, 0x52, + 0xe6, 0x96, 0xbf, 0x32, 0x26, 0xc1, 0x08, 0x52, 0x7d, 0x7b, 0x22, 0x24, 0xf1, 0xfe, 0x2d, 0x58, + 0x1b, 0xb5, 0xc5, 0x6f, 0x14, 0x77, 0xb7, 0x18, 0x5d, 0x7d, 0xff, 0x45, 0xd0, 0x71, 0xf8, 0xea, + 0xfc, 0x77, 0xcf, 0x1f, 0x5e, 0xd7, 0x76, 0x0f, 0x1e, 0x9f, 0xd4, 0xb4, 0x27, 0x27, 0x35, 0xed, + 0xaf, 0x93, 0x9a, 0xf6, 0xf3, 0x69, 0xad, 0xf4, 0xe4, 0xb4, 0x56, 0xfa, 0xe3, 0xb4, 0x56, 0xfa, + 0xc2, 0xf4, 0xb1, 0x68, 0x75, 0x1d, 0xc3, 0xa5, 0x81, 0x09, 0xdb, 0x6d, 0x4c, 0x1c, 0x2c, 0xb8, + 0x29, 0xbf, 0x52, 0xee, 0x9b, 0xd9, 0x8f, 0x15, 0xf9, 0x0e, 0x74, 0x16, 0xe4, 0x77, 0xca, 0x7b, + 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x81, 0xc0, 0xa8, 0x27, 0x41, 0x0e, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1556,10 +1557,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 } @@ -1981,7 +1982,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)) } @@ -2948,7 +2949,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 { @@ -2976,7 +2977,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 diff --git a/x/vaas/types/wire.pb.go b/x/vaas/types/wire.pb.go index f32b100..10eb5ee 100644 --- a/x/vaas/types/wire.pb.go +++ b/x/vaas/types/wire.pb.go @@ -6,6 +6,7 @@ package types import ( fmt "fmt" types "github.com/cometbft/cometbft/abci/types" + _ "github.com/cosmos/cosmos-proto" _ "github.com/cosmos/cosmos-sdk/x/staking/types" _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/cosmos/gogoproto/proto" @@ -108,28 +109,28 @@ func init() { func init() { proto.RegisterFile("vaas/v1/wire.proto", fileDescriptor_17a432f87dfb1130) } var fileDescriptor_17a432f87dfb1130 = []byte{ - // 321 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x91, 0xb1, 0x4a, 0xc3, 0x40, - 0x18, 0xc7, 0x73, 0x56, 0x54, 0x22, 0x14, 0x0d, 0x0e, 0xa1, 0x4a, 0x1a, 0x8a, 0x48, 0xa6, 0x1c, - 0xd1, 0xcd, 0x49, 0x6a, 0x97, 0x6e, 0x52, 0xd1, 0xc1, 0x25, 0x7c, 0x97, 0x1c, 0xe9, 0xd1, 0xe4, - 0xae, 0xe4, 0xbe, 0x46, 0xfb, 0x16, 0x3e, 0x56, 0xc7, 0x8e, 0x4e, 0x45, 0x9a, 0x37, 0xf0, 0x09, - 0x24, 0x49, 0xa3, 0x88, 0xd3, 0x7d, 0xf7, 0xfb, 0x7e, 0xf7, 0x1f, 0xfe, 0x67, 0x5a, 0x05, 0x80, - 0xa6, 0x45, 0x40, 0x5f, 0x45, 0xce, 0xfd, 0x79, 0xae, 0x50, 0x59, 0x87, 0x15, 0xf3, 0x8b, 0xa0, - 0x77, 0x19, 0x29, 0x9d, 0x29, 0x4d, 0x35, 0xc2, 0x4c, 0xc8, 0x84, 0x16, 0x01, 0xe3, 0x08, 0x41, - 0x7b, 0x6f, 0xf4, 0xde, 0x59, 0xa2, 0x12, 0x55, 0x8f, 0xb4, 0x9a, 0x76, 0xf4, 0x1c, 0xb9, 0x8c, - 0x79, 0x9e, 0x09, 0x89, 0x14, 0x58, 0x24, 0x28, 0x2e, 0xe7, 0x5c, 0x37, 0xcb, 0x41, 0x49, 0xcc, - 0x8b, 0x67, 0x48, 0x45, 0x0c, 0xa8, 0xf2, 0x47, 0x8e, 0xf7, 0x53, 0x90, 0x09, 0x7f, 0x80, 0x68, - 0xc6, 0x71, 0x04, 0x08, 0x96, 0x32, 0x4f, 0x8b, 0x76, 0x1f, 0x2e, 0xe6, 0x31, 0x20, 0xd7, 0x36, - 0x71, 0x3b, 0xde, 0xf1, 0xb5, 0xeb, 0xff, 0x26, 0xfb, 0x55, 0xb2, 0xff, 0x93, 0xf4, 0x54, 0x8b, - 0x43, 0x77, 0xb5, 0xe9, 0x1b, 0x5f, 0x9b, 0xbe, 0xbd, 0x84, 0x2c, 0xbd, 0x1d, 0xfc, 0x0b, 0x1a, - 0x4c, 0x4e, 0x8a, 0xbf, 0x4f, 0xb4, 0xe5, 0x99, 0x15, 0xd3, 0x1c, 0x77, 0x52, 0x28, 0x62, 0x7b, - 0xcf, 0x25, 0xde, 0xfe, 0xa4, 0xdb, 0xf0, 0x46, 0x1c, 0xc7, 0x95, 0x19, 0x29, 0xa9, 0x17, 0x19, - 0xcf, 0x43, 0x21, 0xc3, 0x98, 0x33, 0xb4, 0x3b, 0x2e, 0xf1, 0x8e, 0x26, 0xdd, 0x96, 0x8f, 0xe5, - 0x88, 0x33, 0x1c, 0xde, 0xad, 0xb6, 0x0e, 0x59, 0x6f, 0x1d, 0xf2, 0xb9, 0x75, 0xc8, 0x7b, 0xe9, - 0x18, 0xeb, 0xd2, 0x31, 0x3e, 0x4a, 0xc7, 0x78, 0xb9, 0x4a, 0x04, 0x4e, 0x17, 0xcc, 0x8f, 0x54, - 0x46, 0x21, 0x4d, 0x85, 0x64, 0x02, 0x35, 0xad, 0xbf, 0xe2, 0xad, 0x39, 0xea, 0xb6, 0xd8, 0x41, - 0x5d, 0xd7, 0xcd, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa5, 0xee, 0x04, 0x36, 0xa6, 0x01, 0x00, - 0x00, + // 333 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x91, 0xc1, 0x4a, 0xeb, 0x40, + 0x14, 0x86, 0x33, 0xb7, 0x97, 0x7b, 0x2f, 0xb9, 0x50, 0x34, 0xb8, 0x88, 0x55, 0xd2, 0x50, 0x44, + 0xb2, 0xca, 0x10, 0xdd, 0xb9, 0x92, 0xda, 0x4d, 0x77, 0x52, 0xd1, 0x85, 0x9b, 0x70, 0x26, 0x19, + 0xd2, 0xa1, 0xc9, 0x4c, 0xc9, 0x9c, 0x46, 0xfb, 0x16, 0x3e, 0x56, 0x97, 0x5d, 0xba, 0x2a, 0xd2, + 0xbc, 0x81, 0x4f, 0x20, 0xc9, 0xb4, 0x8a, 0xb8, 0x9a, 0x73, 0xfe, 0xff, 0x3b, 0xff, 0x81, 0x33, + 0xb6, 0x53, 0x01, 0x68, 0x5a, 0x45, 0xf4, 0x49, 0x94, 0x3c, 0x9c, 0x97, 0x0a, 0x95, 0xf3, 0xb7, + 0xd1, 0xc2, 0x2a, 0xea, 0x9d, 0x25, 0x4a, 0x17, 0x4a, 0x53, 0x8d, 0x30, 0x13, 0x32, 0xa3, 0x55, + 0xc4, 0x38, 0x42, 0xb4, 0xef, 0x0d, 0xde, 0x3b, 0xca, 0x54, 0xa6, 0xda, 0x92, 0x36, 0xd5, 0x4e, + 0x3d, 0x41, 0x2e, 0x53, 0x5e, 0x16, 0x42, 0x22, 0x05, 0x96, 0x08, 0x8a, 0xcb, 0x39, 0xd7, 0x3b, + 0xf3, 0xd8, 0x04, 0xc7, 0x66, 0xca, 0x34, 0xc6, 0x1a, 0xd4, 0xc4, 0x3e, 0x7d, 0x80, 0x5c, 0xa4, + 0x80, 0xaa, 0xbc, 0xe3, 0x78, 0x33, 0x05, 0x99, 0xf1, 0x5b, 0x48, 0x66, 0x1c, 0x47, 0x80, 0xe0, + 0x28, 0xfb, 0xb0, 0xda, 0xfb, 0xf1, 0x62, 0x9e, 0x02, 0x72, 0xed, 0x12, 0xbf, 0x13, 0xfc, 0xbf, + 0xf0, 0xc3, 0xaf, 0xa5, 0x61, 0xb3, 0x34, 0xfc, 0x4c, 0xba, 0x6f, 0xc1, 0xa1, 0xbf, 0xda, 0xf4, + 0xad, 0xf7, 0x4d, 0xdf, 0x5d, 0x42, 0x91, 0x5f, 0x0d, 0x7e, 0x04, 0x0d, 0x26, 0x07, 0xd5, 0xf7, + 0x11, 0xed, 0x04, 0x76, 0xa3, 0x69, 0x8e, 0x3b, 0x28, 0x16, 0xa9, 0xfb, 0xcb, 0x27, 0xc1, 0xef, + 0x49, 0xd7, 0xe8, 0x06, 0x1c, 0xa7, 0x0d, 0x99, 0x28, 0xa9, 0x17, 0x05, 0x2f, 0x63, 0x21, 0xe3, + 0x94, 0x33, 0x74, 0x3b, 0x3e, 0x09, 0xfe, 0x4d, 0xba, 0x7b, 0x7d, 0x2c, 0x47, 0x9c, 0xe1, 0xf0, + 0x7a, 0xb5, 0xf5, 0xc8, 0x7a, 0xeb, 0x91, 0xb7, 0xad, 0x47, 0x5e, 0x6a, 0xcf, 0x5a, 0xd7, 0x9e, + 0xf5, 0x5a, 0x7b, 0xd6, 0xe3, 0x79, 0x26, 0x70, 0xba, 0x60, 0x61, 0xa2, 0x0a, 0x0a, 0x79, 0x2e, + 0x24, 0x13, 0xa8, 0x69, 0xfb, 0x4b, 0xcf, 0xe6, 0x69, 0x0f, 0xc9, 0xfe, 0xb4, 0xe7, 0xba, 0xfc, + 0x08, 0x00, 0x00, 0xff, 0xff, 0x0e, 0x4a, 0x54, 0xd8, 0xc1, 0x01, 0x00, 0x00, } func (m *ValidatorSetChangePacketData) Marshal() (dAtA []byte, err error) { From 6fe50542d6d30d69ac61b5a3f11dc4d6348372b0 Mon Sep 17 00:00:00 2001 From: Julien Robert Date: Thu, 4 Jun 2026 15:06:39 +0200 Subject: [PATCH 2/4] losen checks --- x/vaas/provider/keeper/msg_server.go | 12 ++++-------- x/vaas/provider/keeper/msg_server_test.go | 15 +++++++++------ 2 files changed, 13 insertions(+), 14 deletions(-) diff --git a/x/vaas/provider/keeper/msg_server.go b/x/vaas/provider/keeper/msg_server.go index cfcb2e2..167a157 100644 --- a/x/vaas/provider/keeper/msg_server.go +++ b/x/vaas/provider/keeper/msg_server.go @@ -342,20 +342,16 @@ func (k msgServer) UpdateConsumer(goCtx context.Context, msg *types.MsgUpdateCon isLaunched := k.GetConsumerPhase(ctx, consumerId) == types.CONSUMER_PHASE_LAUNCHED - // When the chain is already launched, the owner can only update metadata. - // Chain-id, initialization parameters, and owner transfer are restricted to pre-launch phases. + // 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; only metadata updates are allowed after launch") - } - if strings.TrimSpace(msg.NewOwnerAddress) != "" { - return &resp, errorsmod.Wrapf(types.ErrInvalidPhase, - "cannot transfer ownership of a launched chain; only metadata updates are allowed after launch") + "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; only metadata updates are allowed after launch") + "cannot update initialization parameters of a launched chain") } } diff --git a/x/vaas/provider/keeper/msg_server_test.go b/x/vaas/provider/keeper/msg_server_test.go index 69a0b7e..c5a8752 100644 --- a/x/vaas/provider/keeper/msg_server_test.go +++ b/x/vaas/provider/keeper/msg_server_test.go @@ -753,20 +753,23 @@ func TestUpdateConsumerLaunchedOnlyMetadata(t *testing.T) { require.Error(t, err) require.ErrorIs(t, err, providertypes.ErrInvalidPhase) - // owner transfer should fail + // owner transfer should succeed on launched chain + newOwner := "cosmos1dkas8mu4kyhl5jrh4nzvm65qz588hy9qcz08la" _, err = msgServer.UpdateConsumer(ctx, &providertypes.MsgUpdateConsumer{ Owner: "submitter", ConsumerId: consumerId, - NewOwnerAddress: "cosmos1dkas8mu4kyhl5jrh4nzvm65qz588hy9qcz08la", + NewOwnerAddress: newOwner, }) - require.Error(t, err) - require.ErrorIs(t, err, providertypes.ErrInvalidPhase) + require.NoError(t, err) + actualOwner, err := providerKeeper.GetConsumerOwnerAddress(ctx, consumerId) + require.NoError(t, err) + require.Equal(t, newOwner, actualOwner) - // initialization parameters update should fail + // initialization parameters update should fail (use new owner since ownership was transferred) _, err = msgServer.UpdateConsumer(ctx, &providertypes.MsgUpdateConsumer{ - Owner: "submitter", + Owner: newOwner, ConsumerId: consumerId, InitializationParameters: &providertypes.ConsumerInitializationParameters{ SpawnTime: time.Now().Add(24 * time.Hour), From 3cd22a8d3a3cba5b7fdcdb84a10f22e92c321920 Mon Sep 17 00:00:00 2001 From: Julien Robert Date: Thu, 4 Jun 2026 15:22:11 +0200 Subject: [PATCH 3/4] clean up cmd --- x/vaas/provider/client/cli/tx.go | 52 ++------------------------------ 1 file changed, 2 insertions(+), 50 deletions(-) diff --git a/x/vaas/provider/client/cli/tx.go b/x/vaas/provider/client/cli/tx.go index 8ef73d9..2b81541 100644 --- a/x/vaas/provider/client/cli/tx.go +++ b/x/vaas/provider/client/cli/tx.go @@ -36,7 +36,6 @@ func GetTxCmd() *cobra.Command { cmd.AddCommand(NewSubmitConsumerDoubleVotingCmd()) cmd.AddCommand(NewCreateConsumerCmd()) cmd.AddCommand(NewUpdateConsumerCmd()) - cmd.AddCommand(NewRemoveConsumerCmd()) return cmd } @@ -253,8 +252,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 { @@ -384,50 +383,3 @@ If one of the fields is missing, it will be set to its zero value. return cmd } - -func NewRemoveConsumerCmd() *cobra.Command { - cmd := &cobra.Command{ - Use: "remove-consumer [consumer-id]", - Short: "remove a consumer chain (gov authority only)", - Long: strings.TrimSpace( - fmt.Sprintf(`Removes (and stops) a consumer chain. Only the governance authority can remove a consumer chain. -Example: -%s tx provider remove-consumer [consumer-id] -`, version.AppName)), - Args: cobra.ExactArgs(1), - RunE: func(cmd *cobra.Command, args []string) error { - clientCtx, err := client.GetClientTxContext(cmd) - if err != nil { - return err - } - - txf, err := tx.NewFactoryCLI(clientCtx, cmd.Flags()) - if err != nil { - return err - } - txf = txf.WithTxConfig(clientCtx.TxConfig).WithAccountRetriever(clientCtx.AccountRetriever) - - authority := clientCtx.GetFromAddress().String() - consumerId, err := parseConsumerIdArg(args[0]) - if err != nil { - return err - } - - msg, err := types.NewMsgRemoveConsumer(authority, consumerId) - if err != nil { - return err - } - if err := msg.ValidateBasic(); err != nil { - return err - } - - return tx.GenerateOrBroadcastTxWithFactory(clientCtx, txf, msg) - }, - } - - flags.AddTxFlagsToCmd(cmd) - - _ = cmd.MarkFlagRequired(flags.FlagFrom) - - return cmd -} From 20ee29adc368a1b3ba40bf27528da148c8c6a5d3 Mon Sep 17 00:00:00 2001 From: Julien Robert Date: Fri, 5 Jun 2026 16:54:38 +0200 Subject: [PATCH 4/4] add grace period --- proto/vaas/provider/v1/provider.proto | 6 + .../provider/keeper/consumer_equivocation.go | 35 ++- .../keeper/consumer_equivocation_test.go | 152 ++++++++++- x/vaas/provider/types/params.go | 9 + x/vaas/provider/types/params_test.go | 35 +++ x/vaas/provider/types/provider.pb.go | 244 +++++++++++------- 6 files changed, 381 insertions(+), 100 deletions(-) diff --git a/proto/vaas/provider/v1/provider.proto b/proto/vaas/provider/v1/provider.proto index 4b6e1d2..9752fe5 100644 --- a/proto/vaas/provider/v1/provider.proto +++ b/proto/vaas/provider/v1/provider.proto @@ -199,6 +199,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/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/types/params.go b/x/vaas/provider/types/params.go index 3173d92..cb6200d 100644 --- a/x/vaas/provider/types/params.go +++ b/x/vaas/provider/types/params.go @@ -42,6 +42,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 ) // NewParams creates new provider parameters with provided arguments @@ -86,6 +91,7 @@ func DefaultInfractionParameters() InfractionParameters { SlashFraction: downtimeSlashFraction, Tombstone: false, }, + DowntimeGracePeriod: DefaultDowntimeGracePeriod, } } @@ -118,6 +124,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 a3a88a7..58cc46b 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 74d51d0..0421d64 100644 --- a/x/vaas/provider/types/provider.pb.go +++ b/x/vaas/provider/types/provider.pb.go @@ -815,6 +815,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{} } @@ -864,6 +869,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 @@ -940,95 +952,96 @@ func init() { func init() { proto.RegisterFile("vaas/provider/v1/provider.proto", fileDescriptor_6404dd5d21545279) } var fileDescriptor_6404dd5d21545279 = []byte{ - // 1400 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xcd, 0x6f, 0xdb, 0x46, - 0x16, 0x37, 0x2d, 0x25, 0xb1, 0x47, 0xb2, 0x57, 0x99, 0x18, 0x89, 0xec, 0x24, 0x92, 0xa3, 0x45, - 0x76, 0x8d, 0xec, 0x86, 0x84, 0x52, 0xa0, 0x28, 0xda, 0x43, 0x60, 0x49, 0x4c, 0xac, 0xda, 0x71, - 0x04, 0x4a, 0xe9, 0x21, 0x68, 0x41, 0x0c, 0xc9, 0x89, 0x34, 0x31, 0xc9, 0x21, 0x38, 0x23, 0x39, - 0xea, 0xb9, 0x05, 0x7a, 0x4c, 0x81, 0x1e, 0x8a, 0x9e, 0x5a, 0xf4, 0xd2, 0x63, 0x0e, 0x45, 0x8f, - 0x3d, 0xa7, 0xb7, 0xa0, 0xa7, 0xa2, 0x28, 0xd2, 0x22, 0x39, 0xe4, 0x7f, 0xe8, 0xa9, 0x98, 0xe1, - 0x90, 0xa2, 0x3f, 0x82, 0x3a, 0xe8, 0x45, 0xe2, 0xfc, 0xde, 0xfb, 0xcd, 0xfb, 0x98, 0x37, 0xef, - 0x0d, 0xa8, 0x4f, 0x10, 0x62, 0x46, 0x14, 0xd3, 0x09, 0xf1, 0x70, 0x6c, 0x4c, 0x9a, 0xd9, 0xb7, - 0x1e, 0xc5, 0x94, 0x53, 0x58, 0x11, 0x0a, 0x7a, 0x06, 0x4e, 0x9a, 0x6b, 0x67, 0x51, 0x40, 0x42, - 0x6a, 0xc8, 0xdf, 0x44, 0x69, 0xad, 0xe6, 0x52, 0x16, 0x50, 0x66, 0x38, 0x88, 0x61, 0x63, 0xd2, - 0x74, 0x30, 0x47, 0x4d, 0xc3, 0xa5, 0x24, 0x54, 0xf2, 0xd5, 0x44, 0x6e, 0xcb, 0x95, 0x91, 0x2c, - 0x94, 0x68, 0x65, 0x48, 0x87, 0x34, 0xc1, 0xc5, 0x97, 0x42, 0xff, 0xa3, 0x36, 0xc4, 0xc2, 0x6a, - 0xe8, 0xce, 0x36, 0x4d, 0x81, 0xd4, 0xf0, 0x90, 0xd2, 0xa1, 0x8f, 0x0d, 0xb9, 0x72, 0xc6, 0x0f, - 0x0c, 0x6f, 0x1c, 0x23, 0x4e, 0x68, 0x6a, 0xb8, 0x7e, 0x58, 0xce, 0x49, 0x80, 0x19, 0x47, 0x41, - 0x94, 0x2a, 0x10, 0xc7, 0x35, 0x5c, 0x1a, 0x63, 0xc3, 0xf5, 0x09, 0x0e, 0xb9, 0xc8, 0x40, 0xf2, - 0xa5, 0x14, 0x0c, 0xa1, 0xe0, 0x93, 0xe1, 0x88, 0x27, 0x30, 0x33, 0x38, 0x0e, 0x3d, 0x1c, 0x07, - 0x24, 0x51, 0x9e, 0xad, 0x14, 0x01, 0xca, 0x8c, 0x4e, 0x9a, 0xc6, 0x3e, 0x89, 0x53, 0x37, 0x2f, - 0xe5, 0x38, 0x6e, 0x3c, 0x8d, 0x38, 0x35, 0xf6, 0xf0, 0x54, 0xa5, 0xa0, 0xf1, 0x45, 0x01, 0x9c, - 0xee, 0xa1, 0x18, 0x05, 0x0c, 0xbe, 0x03, 0xaa, 0x3c, 0x1e, 0x33, 0x4e, 0xc2, 0xa1, 0x1d, 0xe1, - 0x98, 0x50, 0xcf, 0x7e, 0x10, 0x23, 0x57, 0x44, 0x54, 0xd5, 0xd6, 0xb5, 0x8d, 0x45, 0xeb, 0x7c, - 0x2a, 0xef, 0x49, 0xf1, 0x2d, 0x25, 0x85, 0x7d, 0x70, 0x4e, 0x18, 0xb6, 0x45, 0x80, 0x74, 0xcc, - 0x15, 0xbb, 0x3a, 0xbf, 0xae, 0x6d, 0x94, 0x6e, 0xac, 0xea, 0x49, 0x1e, 0xf4, 0x34, 0x0f, 0x7a, - 0x47, 0xe5, 0xa9, 0xb5, 0xf0, 0xf4, 0x79, 0x7d, 0xee, 0xcb, 0xdf, 0xeb, 0x9a, 0x75, 0x56, 0xf0, - 0x07, 0x09, 0x3d, 0xd9, 0x1c, 0x6e, 0x80, 0x8a, 0xe3, 0x53, 0x77, 0x8f, 0x89, 0xed, 0x6c, 0x1c, - 0x51, 0x77, 0x54, 0x2d, 0xac, 0x6b, 0x1b, 0x05, 0x6b, 0x39, 0xc1, 0x7b, 0x38, 0x36, 0x05, 0x0a, - 0xbb, 0xe0, 0x4a, 0x80, 0x1e, 0xd9, 0x69, 0x9d, 0xd8, 0x2e, 0x0d, 0x19, 0x0e, 0xd9, 0x98, 0xd9, - 0x13, 0xe4, 0x13, 0x0f, 0x71, 0x1a, 0xb3, 0x6a, 0x51, 0x52, 0x6b, 0x01, 0x7a, 0xd4, 0x53, 0x7a, - 0xed, 0x54, 0xed, 0x83, 0x4c, 0x0b, 0x7e, 0xaa, 0x81, 0xe5, 0x07, 0x18, 0x27, 0x36, 0xa5, 0x99, - 0xea, 0x29, 0x15, 0x85, 0xaa, 0x1c, 0x51, 0x66, 0xba, 0xaa, 0x08, 0xbd, 0x4d, 0x49, 0xd8, 0xea, - 0x88, 0x28, 0xfe, 0x7c, 0x5e, 0xff, 0xef, 0x90, 0xf0, 0xd1, 0xd8, 0xd1, 0x5d, 0x1a, 0xa8, 0x32, - 0x53, 0x7f, 0xd7, 0x99, 0xb7, 0x67, 0xf0, 0x69, 0x84, 0x99, 0x24, 0x7c, 0xf5, 0xea, 0xc9, 0xb5, - 0x92, 0x8f, 0x87, 0xc8, 0x9d, 0xda, 0xa2, 0x4e, 0xbf, 0x7b, 0xf5, 0xe4, 0x9a, 0x66, 0x95, 0x85, - 0xd9, 0x1e, 0x8e, 0x5b, 0xc2, 0x68, 0xe3, 0x7f, 0xa0, 0xb4, 0xe9, 0x79, 0x31, 0x66, 0x6c, 0x87, - 0x30, 0x0e, 0x2f, 0x81, 0x45, 0x94, 0x2c, 0x31, 0xab, 0x6a, 0xeb, 0x85, 0x8d, 0xb2, 0x35, 0x03, - 0x1a, 0x1f, 0x82, 0xd5, 0x2c, 0x84, 0x3e, 0xe6, 0xed, 0x11, 0x0a, 0x87, 0xb8, 0x87, 0xdc, 0x3d, - 0xcc, 0x19, 0xbc, 0x09, 0x8a, 0x3e, 0x61, 0x5c, 0xb2, 0x4a, 0x37, 0xae, 0xea, 0xf2, 0x4a, 0x4d, - 0x9a, 0xfa, 0xeb, 0x18, 0x1d, 0xc4, 0x51, 0xab, 0x28, 0x42, 0xb2, 0x24, 0xb1, 0xf1, 0xb9, 0x06, - 0xaa, 0xdb, 0x78, 0xba, 0xc9, 0x18, 0x19, 0x86, 0x01, 0x0e, 0xb9, 0x85, 0x23, 0x1f, 0xb9, 0x58, - 0x7c, 0xc2, 0x7f, 0x83, 0xa5, 0x2c, 0xed, 0xc2, 0x21, 0x59, 0x28, 0x65, 0xab, 0x9c, 0x82, 0x22, - 0x08, 0xf8, 0x2e, 0x00, 0x51, 0x8c, 0x27, 0xb6, 0x6b, 0xef, 0xe1, 0xa9, 0xaa, 0x8a, 0x4b, 0x7a, - 0xae, 0x78, 0x93, 0xb2, 0xd4, 0x7b, 0x63, 0xc7, 0x27, 0xee, 0x36, 0x9e, 0x5a, 0x0b, 0x42, 0xbf, - 0xbd, 0x8d, 0xa7, 0x70, 0x05, 0x9c, 0x8a, 0xe8, 0x3e, 0x8e, 0xd5, 0xd1, 0x27, 0x8b, 0xc6, 0xd7, - 0x1a, 0xb8, 0x90, 0x05, 0x20, 0xce, 0x71, 0x1c, 0xe0, 0xb8, 0x37, 0x76, 0x04, 0xa3, 0x0e, 0x4a, - 0xae, 0x42, 0x6c, 0xe2, 0x49, 0x87, 0x8a, 0x16, 0x48, 0xa1, 0xae, 0x77, 0xd4, 0xe7, 0xf9, 0x63, - 0x7c, 0xbe, 0x09, 0xca, 0xd9, 0x2e, 0xc2, 0xeb, 0xc2, 0x09, 0xbc, 0xce, 0xec, 0x6e, 0xe3, 0x69, - 0xe3, 0x93, 0xbc, 0x8b, 0xad, 0x69, 0xea, 0xa4, 0xdc, 0xfc, 0x24, 0x2e, 0x66, 0x0a, 0x79, 0x17, - 0xdd, 0xfc, 0x2e, 0x47, 0xe2, 0x28, 0x1c, 0x8d, 0xa3, 0xf1, 0xa3, 0x06, 0x56, 0xf2, 0xb6, 0xd9, - 0x80, 0xf6, 0xe2, 0x71, 0x88, 0xff, 0xde, 0x87, 0x9b, 0x60, 0x21, 0x12, 0x9a, 0x36, 0x67, 0xea, - 0xcc, 0xd6, 0x8e, 0xdc, 0xe4, 0x41, 0xda, 0xd1, 0x92, 0xab, 0xfc, 0x58, 0x5c, 0xe5, 0x33, 0x92, - 0x35, 0x60, 0xb0, 0x03, 0x96, 0x0f, 0x04, 0xc1, 0x54, 0x12, 0x2f, 0xeb, 0x87, 0xdb, 0xba, 0x9e, - 0xab, 0x75, 0x6b, 0x29, 0x1f, 0x24, 0x6b, 0xfc, 0xa0, 0x01, 0x78, 0xf4, 0xa6, 0xc2, 0xff, 0x03, - 0x78, 0xe0, 0xbe, 0xe7, 0xab, 0xaf, 0x12, 0xe5, 0x6e, 0xb8, 0x4c, 0x55, 0x56, 0x45, 0xf3, 0xb9, - 0x2a, 0x82, 0xef, 0x01, 0x10, 0xc9, 0xc3, 0x3b, 0xf1, 0x09, 0x2f, 0x46, 0xe9, 0xa7, 0xc8, 0xdf, - 0x43, 0x4a, 0x42, 0x7b, 0x84, 0x45, 0x7f, 0x56, 0xed, 0x05, 0x08, 0x68, 0x4b, 0x22, 0x0d, 0x0f, - 0x54, 0xd2, 0xc4, 0xdf, 0xc1, 0x1c, 0x79, 0x88, 0x23, 0x08, 0x41, 0x31, 0x44, 0x01, 0x56, 0xed, - 0x54, 0x7e, 0xc3, 0x75, 0x50, 0xf2, 0x30, 0x73, 0x63, 0x12, 0xc9, 0x4e, 0x3b, 0x2f, 0x45, 0x79, - 0x08, 0xae, 0x81, 0x85, 0x40, 0xed, 0x20, 0xbd, 0x5c, 0xb4, 0xb2, 0x75, 0xe3, 0x69, 0x01, 0xac, - 0xa7, 0x66, 0xba, 0x21, 0xe1, 0x04, 0xf9, 0xe4, 0x63, 0xd9, 0x5d, 0x65, 0x57, 0xc7, 0x1c, 0xc7, - 0x0c, 0xde, 0x06, 0xcb, 0x24, 0x91, 0xa5, 0xee, 0x6a, 0xea, 0x40, 0x89, 0xe3, 0xea, 0x62, 0x02, - 0xe9, 0x6a, 0xee, 0x4c, 0x9a, 0x7a, 0xe2, 0xbe, 0x6a, 0x01, 0x4b, 0x8a, 0x97, 0x80, 0xf0, 0x0a, - 0x28, 0x0f, 0x71, 0x88, 0x19, 0x61, 0xf6, 0x08, 0xb1, 0x91, 0x2a, 0xcb, 0x92, 0xc2, 0xb6, 0x10, - 0x1b, 0x89, 0xbc, 0x38, 0x24, 0x44, 0xf1, 0x34, 0xd1, 0x48, 0x6a, 0x12, 0x24, 0x90, 0x54, 0x68, - 0x03, 0xc0, 0x22, 0xb4, 0x1f, 0xca, 0x69, 0x21, 0xf3, 0x76, 0xd2, 0xca, 0x5a, 0x94, 0x3c, 0x21, - 0x81, 0xbb, 0xa0, 0x32, 0x0e, 0x1d, 0x1a, 0x7a, 0xb3, 0x61, 0x95, 0x35, 0xea, 0x13, 0x8c, 0x9b, - 0x7f, 0x65, 0x64, 0x35, 0x6c, 0x5e, 0x33, 0xc1, 0x4e, 0xff, 0xa3, 0x09, 0x76, 0x1d, 0xc0, 0x11, - 0x61, 0x9c, 0xc6, 0xc4, 0x45, 0xbe, 0x8d, 0x43, 0x1e, 0x13, 0xcc, 0xaa, 0x67, 0x64, 0xa5, 0x9c, - 0x9d, 0x49, 0xcc, 0x44, 0xd0, 0xa8, 0x83, 0x52, 0x76, 0x92, 0x1e, 0x83, 0x15, 0x50, 0x20, 0x5e, - 0xd2, 0xed, 0x8b, 0x96, 0xf8, 0x6c, 0x7c, 0xa3, 0x81, 0x95, 0x6e, 0x98, 0xce, 0xe4, 0xdc, 0xf9, - 0xde, 0x02, 0x25, 0x8f, 0x8e, 0x1d, 0x1f, 0xdb, 0xa2, 0x47, 0xab, 0xc3, 0xbd, 0x7a, 0xf4, 0x9a, - 0xf5, 0x7d, 0xc4, 0x46, 0xef, 0x23, 0xe2, 0xcf, 0xb8, 0x16, 0x48, 0x98, 0x7d, 0x32, 0x0c, 0xe1, - 0x26, 0x58, 0xf0, 0xe8, 0x7e, 0x28, 0x0f, 0x66, 0xfe, 0x4d, 0x36, 0xc9, 0x68, 0x8d, 0xdf, 0x34, - 0x70, 0xee, 0x18, 0x0d, 0xf8, 0x11, 0x58, 0x66, 0x02, 0x3e, 0xf8, 0xa4, 0x28, 0xb7, 0xde, 0x16, - 0x09, 0xfc, 0xf5, 0x79, 0xfd, 0x62, 0x32, 0x2a, 0x99, 0xb7, 0xa7, 0x13, 0x6a, 0x04, 0x88, 0x8f, - 0xf4, 0x1d, 0x39, 0x22, 0x3b, 0xd8, 0xfd, 0xf9, 0xfb, 0xeb, 0x40, 0x4d, 0xdf, 0x0e, 0x76, 0x93, - 0x71, 0xb9, 0x24, 0x77, 0xcb, 0x5e, 0x20, 0x5b, 0x60, 0xe9, 0x21, 0x22, 0xbe, 0x9d, 0x3e, 0xc1, - 0xde, 0xe4, 0xed, 0x51, 0x16, 0xcc, 0x14, 0x17, 0xa3, 0x96, 0xd3, 0xc0, 0x61, 0x9c, 0x86, 0x58, - 0x56, 0xef, 0x82, 0x35, 0x03, 0xae, 0xfd, 0xa4, 0x81, 0xa5, 0x6c, 0xde, 0x8c, 0x10, 0xc3, 0xb0, - 0x06, 0xd6, 0xda, 0x77, 0x77, 0xfb, 0xf7, 0xee, 0x98, 0x96, 0xdd, 0xdb, 0xda, 0xec, 0x9b, 0xf6, - 0xbd, 0xdd, 0x7e, 0xcf, 0x6c, 0x77, 0x6f, 0x75, 0xcd, 0x4e, 0x65, 0x0e, 0x5e, 0x06, 0xab, 0x87, - 0xe4, 0x96, 0x79, 0xbb, 0xdb, 0x1f, 0x98, 0x96, 0xd9, 0xa9, 0x68, 0xc7, 0xd0, 0xbb, 0xbb, 0xdd, - 0x41, 0x77, 0x73, 0xa7, 0x7b, 0xdf, 0xec, 0x54, 0xe6, 0xe1, 0x45, 0x70, 0xe1, 0x90, 0x7c, 0x67, - 0xf3, 0xde, 0x6e, 0x7b, 0xcb, 0xec, 0x54, 0x0a, 0x70, 0x0d, 0x9c, 0x3f, 0x24, 0xec, 0x0f, 0xee, - 0xf6, 0x7a, 0x66, 0xa7, 0x52, 0x3c, 0x46, 0xd6, 0x31, 0x77, 0xcc, 0x81, 0xd9, 0xa9, 0x9c, 0x5a, - 0x2b, 0x7e, 0xf6, 0x6d, 0x6d, 0xae, 0xd5, 0x7d, 0xfa, 0xa2, 0xa6, 0x3d, 0x7b, 0x51, 0xd3, 0xfe, - 0x78, 0x51, 0xd3, 0x1e, 0xbf, 0xac, 0xcd, 0x3d, 0x7b, 0x59, 0x9b, 0xfb, 0xe5, 0x65, 0x6d, 0xee, - 0xbe, 0x91, 0x7b, 0xc9, 0x20, 0xdf, 0x27, 0xa1, 0x43, 0x38, 0x33, 0xe4, 0xdb, 0xf2, 0x91, 0x71, - 0xf0, 0xd1, 0x2e, 0x9f, 0x35, 0xce, 0x69, 0x99, 0xdf, 0xb7, 0xfe, 0x0a, 0x00, 0x00, 0xff, 0xff, - 0x42, 0xd8, 0xe2, 0x59, 0xd2, 0x0b, 0x00, 0x00, + // 1420 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0xcf, 0x6f, 0x1b, 0xc5, + 0x17, 0xcf, 0xc6, 0x6e, 0x9b, 0x8c, 0x9d, 0x7c, 0xdd, 0x69, 0xbe, 0xad, 0x93, 0xb6, 0x76, 0x6a, + 0x54, 0x88, 0x0a, 0xdd, 0x55, 0x8a, 0x84, 0x10, 0x1c, 0xaa, 0xc4, 0xde, 0x36, 0x26, 0x69, 0x6a, + 0xad, 0x5d, 0x90, 0x2a, 0xd0, 0x6a, 0x76, 0x77, 0x6a, 0x4f, 0xb3, 0xbb, 0xb3, 0xda, 0x19, 0x3b, + 0x35, 0x67, 0x90, 0x38, 0x16, 0x89, 0x03, 0xe2, 0x84, 0xc4, 0x85, 0x63, 0x0f, 0x88, 0x23, 0xe7, + 0x72, 0xab, 0x38, 0x21, 0x84, 0x0a, 0x6a, 0x0f, 0xfd, 0x1f, 0x7a, 0x42, 0xf3, 0x63, 0x37, 0xce, + 0x8f, 0x8a, 0x54, 0x5c, 0x92, 0xd9, 0xf7, 0xde, 0xe7, 0xfd, 0x9e, 0xf7, 0xc6, 0xa0, 0x3e, 0x42, + 0x88, 0x59, 0x49, 0x4a, 0x47, 0x24, 0xc0, 0xa9, 0x35, 0x5a, 0xcd, 0xcf, 0x66, 0x92, 0x52, 0x4e, + 0x61, 0x45, 0x08, 0x98, 0x39, 0x71, 0xb4, 0xba, 0x74, 0x1a, 0x45, 0x24, 0xa6, 0x96, 0xfc, 0xab, + 0x84, 0x96, 0x6a, 0x3e, 0x65, 0x11, 0x65, 0x96, 0x87, 0x18, 0xb6, 0x46, 0xab, 0x1e, 0xe6, 0x68, + 0xd5, 0xf2, 0x29, 0x89, 0x35, 0x7f, 0x51, 0xf1, 0x5d, 0xf9, 0x65, 0xa9, 0x0f, 0xcd, 0x5a, 0xe8, + 0xd3, 0x3e, 0x55, 0x74, 0x71, 0xd2, 0xd4, 0x37, 0xb5, 0x42, 0x2c, 0xac, 0xc6, 0xfe, 0x9e, 0xd2, + 0x8c, 0x90, 0x19, 0xee, 0x53, 0xda, 0x0f, 0xb1, 0x25, 0xbf, 0xbc, 0xe1, 0x3d, 0x2b, 0x18, 0xa6, + 0x88, 0x13, 0x9a, 0x19, 0xae, 0x1f, 0xe4, 0x73, 0x12, 0x61, 0xc6, 0x51, 0x94, 0x64, 0x02, 0xc4, + 0xf3, 0x2d, 0x9f, 0xa6, 0xd8, 0xf2, 0x43, 0x82, 0x63, 0x2e, 0x32, 0xa0, 0x4e, 0x5a, 0xc0, 0x12, + 0x02, 0x21, 0xe9, 0x0f, 0xb8, 0x22, 0x33, 0x8b, 0xe3, 0x38, 0xc0, 0x69, 0x44, 0x94, 0xf0, 0xde, + 0x97, 0x06, 0x40, 0x99, 0xd1, 0xd1, 0xaa, 0xb5, 0x4b, 0xd2, 0xcc, 0xcd, 0x0b, 0x13, 0x18, 0x3f, + 0x1d, 0x27, 0x9c, 0x5a, 0x3b, 0x78, 0xac, 0x53, 0xd0, 0xf8, 0xa6, 0x00, 0x4e, 0x76, 0x50, 0x8a, + 0x22, 0x06, 0xdf, 0x07, 0x55, 0x9e, 0x0e, 0x19, 0x27, 0x71, 0xdf, 0x4d, 0x70, 0x4a, 0x68, 0xe0, + 0xde, 0x4b, 0x91, 0x2f, 0x22, 0xaa, 0x1a, 0xcb, 0xc6, 0xca, 0xac, 0x73, 0x36, 0xe3, 0x77, 0x24, + 0xfb, 0x86, 0xe6, 0xc2, 0x2e, 0x38, 0x23, 0x0c, 0xbb, 0x22, 0x40, 0x3a, 0xe4, 0x1a, 0x5d, 0x9d, + 0x5e, 0x36, 0x56, 0x4a, 0xd7, 0x16, 0x4d, 0x95, 0x07, 0x33, 0xcb, 0x83, 0xd9, 0xd2, 0x79, 0x5a, + 0x9f, 0x79, 0xfc, 0xb4, 0x3e, 0xf5, 0xed, 0x5f, 0x75, 0xc3, 0x39, 0x2d, 0xf0, 0x3d, 0x05, 0x57, + 0xca, 0xe1, 0x0a, 0xa8, 0x78, 0x21, 0xf5, 0x77, 0x98, 0x50, 0xe7, 0xe2, 0x84, 0xfa, 0x83, 0x6a, + 0x61, 0xd9, 0x58, 0x29, 0x38, 0xf3, 0x8a, 0xde, 0xc1, 0xa9, 0x2d, 0xa8, 0xb0, 0x0d, 0x2e, 0x45, + 0xe8, 0x81, 0x9b, 0xf5, 0x89, 0xeb, 0xd3, 0x98, 0xe1, 0x98, 0x0d, 0x99, 0x3b, 0x42, 0x21, 0x09, + 0x10, 0xa7, 0x29, 0xab, 0x16, 0x25, 0xb4, 0x16, 0xa1, 0x07, 0x1d, 0x2d, 0xd7, 0xcc, 0xc4, 0x3e, + 0xce, 0xa5, 0xe0, 0x97, 0x06, 0x98, 0xbf, 0x87, 0xb1, 0xb2, 0x29, 0xcd, 0x54, 0x4f, 0xe8, 0x28, + 0x74, 0xe7, 0x88, 0x36, 0x33, 0x75, 0x47, 0x98, 0x4d, 0x4a, 0xe2, 0xf5, 0x96, 0x88, 0xe2, 0xe5, + 0xd3, 0xfa, 0x5b, 0x7d, 0xc2, 0x07, 0x43, 0xcf, 0xf4, 0x69, 0xa4, 0xdb, 0x4c, 0xff, 0xbb, 0xca, + 0x82, 0x1d, 0x8b, 0x8f, 0x13, 0xcc, 0x24, 0xe0, 0xbb, 0x17, 0x8f, 0xae, 0x94, 0x42, 0xdc, 0x47, + 0xfe, 0xd8, 0x15, 0x7d, 0xfa, 0xe3, 0x8b, 0x47, 0x57, 0x0c, 0xa7, 0x2c, 0xcc, 0x76, 0x70, 0xba, + 0x2e, 0x8c, 0x36, 0xde, 0x06, 0xa5, 0xb5, 0x20, 0x48, 0x31, 0x63, 0x5b, 0x84, 0x71, 0x78, 0x01, + 0xcc, 0x22, 0xf5, 0x89, 0x59, 0xd5, 0x58, 0x2e, 0xac, 0x94, 0x9d, 0x3d, 0x42, 0xe3, 0x53, 0xb0, + 0x98, 0x87, 0xd0, 0xc5, 0xbc, 0x39, 0x40, 0x71, 0x1f, 0x77, 0x90, 0xbf, 0x83, 0x39, 0x83, 0xd7, + 0x41, 0x31, 0x24, 0x8c, 0x4b, 0x54, 0xe9, 0xda, 0x65, 0x53, 0x5e, 0xa9, 0xd1, 0xaa, 0xf9, 0x2a, + 0x44, 0x0b, 0x71, 0xb4, 0x5e, 0x14, 0x21, 0x39, 0x12, 0xd8, 0xf8, 0xda, 0x00, 0xd5, 0x4d, 0x3c, + 0x5e, 0x63, 0x8c, 0xf4, 0xe3, 0x08, 0xc7, 0xdc, 0xc1, 0x49, 0x88, 0x7c, 0x2c, 0x8e, 0xf0, 0x0d, + 0x30, 0x97, 0xa7, 0x5d, 0x38, 0x24, 0x1b, 0xa5, 0xec, 0x94, 0x33, 0xa2, 0x08, 0x02, 0x7e, 0x00, + 0x40, 0x92, 0xe2, 0x91, 0xeb, 0xbb, 0x3b, 0x78, 0xac, 0xbb, 0xe2, 0x82, 0x39, 0xd1, 0xbc, 0xaa, + 0x2d, 0xcd, 0xce, 0xd0, 0x0b, 0x89, 0xbf, 0x89, 0xc7, 0xce, 0x8c, 0x90, 0x6f, 0x6e, 0xe2, 0x31, + 0x5c, 0x00, 0x27, 0x12, 0xba, 0x8b, 0x53, 0x5d, 0x7a, 0xf5, 0xd1, 0xf8, 0xde, 0x00, 0xe7, 0xf2, + 0x00, 0x44, 0x1d, 0x87, 0x11, 0x4e, 0x3b, 0x43, 0x4f, 0x20, 0xea, 0xa0, 0xe4, 0x6b, 0x8a, 0x4b, + 0x02, 0xe9, 0x50, 0xd1, 0x01, 0x19, 0xa9, 0x1d, 0x1c, 0xf6, 0x79, 0xfa, 0x08, 0x9f, 0xaf, 0x83, + 0x72, 0xae, 0x45, 0x78, 0x5d, 0x38, 0x86, 0xd7, 0xb9, 0xdd, 0x4d, 0x3c, 0x6e, 0x7c, 0x31, 0xe9, + 0xe2, 0xfa, 0x38, 0x73, 0x52, 0x2a, 0x3f, 0x8e, 0x8b, 0xb9, 0xc0, 0xa4, 0x8b, 0xfe, 0xa4, 0x96, + 0x43, 0x71, 0x14, 0x0e, 0xc7, 0xd1, 0xf8, 0xc5, 0x00, 0x0b, 0x93, 0xb6, 0x59, 0x8f, 0x76, 0xd2, + 0x61, 0x8c, 0xff, 0xdd, 0x87, 0xeb, 0x60, 0x26, 0x11, 0x92, 0x2e, 0x67, 0xba, 0x66, 0x4b, 0x87, + 0x6e, 0x72, 0x2f, 0x9b, 0x68, 0xea, 0x2a, 0x3f, 0x14, 0x57, 0xf9, 0x94, 0x44, 0xf5, 0x18, 0x6c, + 0x81, 0xf9, 0x7d, 0x41, 0x30, 0x9d, 0xc4, 0x8b, 0xe6, 0xc1, 0xb1, 0x6e, 0x4e, 0xf4, 0xba, 0x33, + 0x37, 0x19, 0x24, 0x6b, 0xfc, 0x6c, 0x00, 0x78, 0xf8, 0xa6, 0xc2, 0x77, 0x00, 0xdc, 0x77, 0xdf, + 0x27, 0xbb, 0xaf, 0x92, 0x4c, 0xdc, 0x70, 0x99, 0xaa, 0xbc, 0x8b, 0xa6, 0x27, 0xba, 0x08, 0x7e, + 0x08, 0x40, 0x22, 0x8b, 0x77, 0xec, 0x0a, 0xcf, 0x26, 0xd9, 0x51, 0xe4, 0xef, 0x3e, 0x25, 0xb1, + 0x3b, 0xc0, 0x62, 0x3e, 0xeb, 0xf1, 0x02, 0x04, 0x69, 0x43, 0x52, 0x1a, 0x01, 0xa8, 0x64, 0x89, + 0xbf, 0x85, 0x39, 0x0a, 0x10, 0x47, 0x10, 0x82, 0x62, 0x8c, 0x22, 0xac, 0xc7, 0xa9, 0x3c, 0xc3, + 0x65, 0x50, 0x0a, 0x30, 0xf3, 0x53, 0x92, 0xc8, 0x49, 0x3b, 0x2d, 0x59, 0x93, 0x24, 0xb8, 0x04, + 0x66, 0x22, 0xad, 0x41, 0x7a, 0x39, 0xeb, 0xe4, 0xdf, 0x8d, 0xc7, 0x05, 0xb0, 0x9c, 0x99, 0x69, + 0xc7, 0x84, 0x13, 0x14, 0x92, 0xcf, 0xe5, 0x74, 0x95, 0x53, 0x1d, 0x73, 0x9c, 0x32, 0x78, 0x13, + 0xcc, 0x13, 0xc5, 0xcb, 0xdc, 0x35, 0x74, 0x41, 0x89, 0xe7, 0x9b, 0x62, 0x03, 0x99, 0x7a, 0xef, + 0x8c, 0x56, 0x4d, 0xe5, 0xbe, 0x1e, 0x01, 0x73, 0x1a, 0xa7, 0x88, 0xf0, 0x12, 0x28, 0xf7, 0x71, + 0x8c, 0x19, 0x61, 0xee, 0x00, 0xb1, 0x81, 0x6e, 0xcb, 0x92, 0xa6, 0x6d, 0x20, 0x36, 0x10, 0x79, + 0xf1, 0x48, 0x8c, 0xd2, 0xb1, 0x92, 0x50, 0x3d, 0x09, 0x14, 0x49, 0x0a, 0x34, 0x01, 0x60, 0x09, + 0xda, 0x8d, 0xe5, 0xb6, 0x90, 0x79, 0x3b, 0x6e, 0x67, 0xcd, 0x4a, 0x9c, 0xe0, 0xc0, 0x6d, 0x50, + 0x19, 0xc6, 0x1e, 0x8d, 0x83, 0xbd, 0x65, 0x95, 0x0f, 0xea, 0x63, 0xac, 0x9b, 0xff, 0xe5, 0x60, + 0xbd, 0x6c, 0x5e, 0xb1, 0xc1, 0x4e, 0xfe, 0xa7, 0x0d, 0x76, 0x15, 0xc0, 0x01, 0x61, 0x9c, 0xa6, + 0xc4, 0x47, 0xa1, 0x8b, 0x63, 0x9e, 0x12, 0xcc, 0xaa, 0xa7, 0x64, 0xa7, 0x9c, 0xde, 0xe3, 0xd8, + 0x8a, 0xd1, 0xa8, 0x83, 0x52, 0x5e, 0xc9, 0x80, 0xc1, 0x0a, 0x28, 0x90, 0x40, 0x4d, 0xfb, 0xa2, + 0x23, 0x8e, 0x8d, 0x97, 0x06, 0x58, 0x68, 0xc7, 0xd9, 0x4e, 0x9e, 0xa8, 0xef, 0x0d, 0x50, 0x0a, + 0xe8, 0xd0, 0x0b, 0xb1, 0x2b, 0x66, 0xb4, 0x2e, 0xee, 0xe5, 0xc3, 0xd7, 0xac, 0x1b, 0x22, 0x36, + 0xf8, 0x08, 0x91, 0x70, 0x0f, 0xeb, 0x00, 0x85, 0xec, 0x92, 0x7e, 0x0c, 0xd7, 0xc0, 0x4c, 0x40, + 0x77, 0x63, 0x59, 0x98, 0xe9, 0xd7, 0x51, 0x92, 0xc3, 0xe0, 0x27, 0xe0, 0xff, 0xd9, 0xd9, 0xed, + 0xa7, 0xc8, 0xc7, 0x59, 0x2a, 0x0b, 0xc7, 0x4f, 0xe5, 0x99, 0x4c, 0xc3, 0x4d, 0xa1, 0x40, 0x25, + 0xb3, 0xf1, 0xa7, 0x01, 0xce, 0x1c, 0x61, 0x1a, 0x7e, 0x06, 0xe6, 0x99, 0x20, 0xef, 0x7f, 0xab, + 0x94, 0xd7, 0xdf, 0x13, 0xea, 0xfe, 0x78, 0x5a, 0x3f, 0xaf, 0x76, 0x30, 0x0b, 0x76, 0x4c, 0x42, + 0xad, 0x08, 0xf1, 0x81, 0xb9, 0x25, 0x77, 0x6f, 0x0b, 0xfb, 0xbf, 0xfd, 0x74, 0x15, 0xe8, 0xb5, + 0xde, 0xc2, 0xbe, 0xda, 0xc3, 0x73, 0x52, 0x5b, 0xfe, 0xb4, 0xd9, 0x00, 0x73, 0xf7, 0x11, 0x09, + 0xdd, 0xec, 0x6d, 0xf7, 0x3a, 0x8f, 0x9a, 0xb2, 0x40, 0x66, 0x74, 0xb1, 0xc3, 0x39, 0x8d, 0x3c, + 0xc6, 0x69, 0x8c, 0x65, 0x36, 0x66, 0x9c, 0x3d, 0xc2, 0x95, 0x5f, 0x0d, 0x30, 0x97, 0x2f, 0xb2, + 0x01, 0x62, 0x18, 0xd6, 0xc0, 0x52, 0xf3, 0xf6, 0x76, 0xf7, 0xce, 0x2d, 0xdb, 0x71, 0x3b, 0x1b, + 0x6b, 0x5d, 0xdb, 0xbd, 0xb3, 0xdd, 0xed, 0xd8, 0xcd, 0xf6, 0x8d, 0xb6, 0xdd, 0xaa, 0x4c, 0xc1, + 0x8b, 0x60, 0xf1, 0x00, 0xdf, 0xb1, 0x6f, 0xb6, 0xbb, 0x3d, 0xdb, 0xb1, 0x5b, 0x15, 0xe3, 0x08, + 0x78, 0x7b, 0xbb, 0xdd, 0x6b, 0xaf, 0x6d, 0xb5, 0xef, 0xda, 0xad, 0xca, 0x34, 0x3c, 0x0f, 0xce, + 0x1d, 0xe0, 0x6f, 0xad, 0xdd, 0xd9, 0x6e, 0x6e, 0xd8, 0xad, 0x4a, 0x01, 0x2e, 0x81, 0xb3, 0x07, + 0x98, 0xdd, 0xde, 0xed, 0x4e, 0xc7, 0x6e, 0x55, 0x8a, 0x47, 0xf0, 0x5a, 0xf6, 0x96, 0xdd, 0xb3, + 0x5b, 0x95, 0x13, 0x4b, 0xc5, 0xaf, 0x7e, 0xa8, 0x4d, 0xad, 0xb7, 0x1f, 0x3f, 0xab, 0x19, 0x4f, + 0x9e, 0xd5, 0x8c, 0xbf, 0x9f, 0xd5, 0x8c, 0x87, 0xcf, 0x6b, 0x53, 0x4f, 0x9e, 0xd7, 0xa6, 0x7e, + 0x7f, 0x5e, 0x9b, 0xba, 0x6b, 0x4d, 0x3c, 0x91, 0x50, 0x18, 0x92, 0xd8, 0x23, 0x9c, 0x59, 0xf2, + 0xd1, 0xfa, 0xc0, 0xda, 0xff, 0x6b, 0x40, 0xbe, 0x97, 0xbc, 0x93, 0x32, 0xbf, 0xef, 0xfe, 0x13, + 0x00, 0x00, 0xff, 0xff, 0xd5, 0x8a, 0x29, 0x1b, 0x2b, 0x0c, 0x00, 0x00, } func (m *Params) Marshal() (dAtA []byte, err error) { @@ -1575,6 +1588,14 @@ func (m *InfractionParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + n14, err14 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.DowntimeGracePeriod, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.DowntimeGracePeriod):]) + if err14 != nil { + return 0, err14 + } + i -= n14 + i = encodeVarintProvider(dAtA, i, uint64(n14)) + i-- + dAtA[i] = 0x1a if m.Downtime != nil { { size, err := m.Downtime.MarshalToSizedBuffer(dAtA[:i]) @@ -1632,12 +1653,12 @@ func (m *SlashJailParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x18 } - 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 + n17, err17 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.JailDuration, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.JailDuration):]) + if err17 != nil { + return 0, err17 } - i -= n16 - i = encodeVarintProvider(dAtA, i, uint64(n16)) + i -= n17 + i = encodeVarintProvider(dAtA, i, uint64(n17)) i-- dAtA[i] = 0x12 { @@ -1897,6 +1918,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 } @@ -3627,6 +3650,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:])