diff --git a/proto/babylon/btcstaking/v1/events.proto b/proto/babylon/btcstaking/v1/events.proto index a8d4fb3e4..30e40aee4 100644 --- a/proto/babylon/btcstaking/v1/events.proto +++ b/proto/babylon/btcstaking/v1/events.proto @@ -40,11 +40,19 @@ message EventPowerDistUpdate { bytes pk = 1 [ (gogoproto.customtype) = "github.com/babylonlabs-io/babylon/types.BIP340PubKey" ]; } + // EventJailedFinalityProvider defines an event that a finality provider + // is jailed + message EventJailedFinalityProvider { + bytes pk = 1 [ (gogoproto.customtype) = "github.com/babylonlabs-io/babylon/types.BIP340PubKey" ]; + } + // ev is the event that affects voting power distribution oneof ev { // slashed_fp means a finality provider is slashed EventSlashedFinalityProvider slashed_fp = 1; + // jailed_fp means a finality provider is jailed + EventJailedFinalityProvider jailed_fp = 2; // btc_del_state_update means a BTC delegation's state is updated - EventBTCDelegationStateUpdate btc_del_state_update = 2; + EventBTCDelegationStateUpdate btc_del_state_update = 3; } } diff --git a/proto/babylon/finality/v1/events.proto b/proto/babylon/finality/v1/events.proto index 1c2fe0947..9eab6232a 100644 --- a/proto/babylon/finality/v1/events.proto +++ b/proto/babylon/finality/v1/events.proto @@ -12,16 +12,9 @@ message EventSlashedFinalityProvider { Evidence evidence = 1; } -// EventSluggishFinalityProviderDetected is the event emitted when a finality provider is -// detected as sluggish -message EventSluggishFinalityProviderDetected { - // public_key is the BTC public key of the finality provider - string public_key = 1; -} - -// EventSluggishFinalityProviderReverted is the event emitted when a sluggish finality -// provider is no longer considered sluggish -message EventSluggishFinalityProviderReverted { +// EventJailedFinalityProvider is the event emitted when a finality provider is +// jailed due to inactivity +message EventJailedFinalityProvider { // public_key is the BTC public key of the finality provider string public_key = 1; } diff --git a/proto/babylon/finality/v1/finality.proto b/proto/babylon/finality/v1/finality.proto index 1167e774a..87216e454 100644 --- a/proto/babylon/finality/v1/finality.proto +++ b/proto/babylon/finality/v1/finality.proto @@ -4,6 +4,8 @@ package babylon.finality.v1; option go_package = "github.com/babylonlabs-io/babylon/x/finality/types"; import "gogoproto/gogo.proto"; +import "amino/amino.proto"; +import "google/protobuf/timestamp.proto"; // IndexedBlock is the necessary metadata and finalization status of a block message IndexedBlock { @@ -64,4 +66,7 @@ message FinalityProviderSigningInfo { // missed_blocks_counter defines a counter to avoid unnecessary array reads. // Note that `Sum(MissedBlocksBitArray)` always equals `MissedBlocksCounter`. int64 missed_blocks_counter = 3; + // Timestamp until which the validator is jailed due to liveness downtime. + google.protobuf.Timestamp jailed_until = 4 + [(gogoproto.stdtime) = true, (gogoproto.nullable) = false, (amino.dont_omitempty) = true]; } diff --git a/proto/babylon/finality/v1/params.proto b/proto/babylon/finality/v1/params.proto index 875497283..eeb72c438 100644 --- a/proto/babylon/finality/v1/params.proto +++ b/proto/babylon/finality/v1/params.proto @@ -4,6 +4,7 @@ package babylon.finality.v1; import "gogoproto/gogo.proto"; import "amino/amino.proto"; import "cosmos_proto/cosmos.proto"; +import "google/protobuf/duration.proto"; option go_package = "github.com/babylonlabs-io/babylon/x/finality/types"; @@ -26,4 +27,7 @@ message Params { // min_pub_rand is the minimum number of public randomness each // message should commit uint64 min_pub_rand = 4; + // jail_duration is the minimum period of time that a finality provider remains jailed + google.protobuf.Duration jail_duration = 5 + [(gogoproto.nullable) = false, (amino.dont_omitempty) = true, (gogoproto.stdduration) = true]; } diff --git a/x/btcstaking/keeper/finality_providers.go b/x/btcstaking/keeper/finality_providers.go index 24a158c71..158b7d11d 100644 --- a/x/btcstaking/keeper/finality_providers.go +++ b/x/btcstaking/keeper/finality_providers.go @@ -102,6 +102,43 @@ func (k Keeper) SlashFinalityProvider(ctx context.Context, fpBTCPK []byte) error return nil } +// JailFinalityProvider jails a finality provider with the given PK +// A jailed finality provider will not have voting power until it is +// unjailed (assuming it still ranks top N and has timestamped pub rand) +func (k Keeper) JailFinalityProvider(ctx context.Context, fpBTCPK []byte) error { + // ensure finality provider exists + fp, err := k.GetFinalityProvider(ctx, fpBTCPK) + if err != nil { + return err + } + + // ensure finality provider is not slashed yet + if fp.IsSlashed() { + return types.ErrFpAlreadySlashed + } + + // ensure finality provider is not jailed yet + if fp.IsJailed() { + return types.ErrFpAlreadySlashed + } + + // set finality provider to be jailed + fp.Jailed = true + k.setFinalityProvider(ctx, fp) + + btcTip := k.btclcKeeper.GetTipInfo(ctx) + if btcTip == nil { + return fmt.Errorf("failed to get current BTC tip") + } + + // record jailed event. The next `BeginBlock` will consume this + // event for updating the finality provider set + powerUpdateEvent := types.NewEventPowerDistUpdateWithJailedFP(fp.BtcPk) + k.addPowerDistUpdateEvent(ctx, btcTip.Height, powerUpdateEvent) + + return nil +} + // RevertSluggishFinalityProvider sets the Sluggish flag of the given finality provider // to false func (k Keeper) RevertSluggishFinalityProvider(ctx context.Context, fpBTCPK []byte) error { @@ -113,11 +150,11 @@ func (k Keeper) RevertSluggishFinalityProvider(ctx context.Context, fpBTCPK []by // ignore the finality provider is already slashed // or detected as sluggish - if fp.IsSlashed() || fp.IsSluggish() { + if fp.IsSlashed() || fp.IsJailed() { return nil } - fp.Sluggish = false + fp.Jailed = false k.setFinalityProvider(ctx, fp) return nil diff --git a/x/btcstaking/keeper/hooks.go b/x/btcstaking/keeper/hooks.go index d17f71f5c..b4d93cefe 100644 --- a/x/btcstaking/keeper/hooks.go +++ b/x/btcstaking/keeper/hooks.go @@ -2,7 +2,6 @@ package keeper import ( "context" - "fmt" bbntypes "github.com/babylonlabs-io/babylon/types" "github.com/babylonlabs-io/babylon/x/finality/types" @@ -22,18 +21,5 @@ func (k Keeper) Hooks() Hooks { // AfterSluggishFinalityProviderDetected updates the status of the given finality provider to `sluggish` func (h Hooks) AfterSluggishFinalityProviderDetected(ctx context.Context, fpPk *bbntypes.BIP340PubKey) error { - fp, err := h.k.GetFinalityProvider(ctx, fpPk.MustMarshal()) - if err != nil { - return err - } - - if fp.IsSluggish() { - return fmt.Errorf("the finality provider %s is already detected as sluggish", fpPk.MarshalHex()) - } - - fp.Sluggish = true - - h.k.setFinalityProvider(ctx, fp) - - return nil + return h.k.JailFinalityProvider(ctx, fpPk.MustMarshal()) } diff --git a/x/btcstaking/keeper/power_dist_change.go b/x/btcstaking/keeper/power_dist_change.go index d924dd5e4..d125b5186 100644 --- a/x/btcstaking/keeper/power_dist_change.go +++ b/x/btcstaking/keeper/power_dist_change.go @@ -69,7 +69,7 @@ func (k Keeper) UpdatePowerDist(ctx context.Context) { // reconcile old voting power distribution cache and new events // to construct the new distribution - newDc := k.ProcessAllPowerDistUpdateEvents(ctx, dc, events, maxActiveFps) + newDc := k.ProcessAllPowerDistUpdateEvents(ctx, dc, events) // record voting power and cache for this height k.recordVotingPowerAndCache(ctx, dc, newDc, maxActiveFps) @@ -150,15 +150,14 @@ func (k Keeper) ProcessAllPowerDistUpdateEvents( ctx context.Context, dc *types.VotingPowerDistCache, events []*types.EventPowerDistUpdate, - maxActiveFps uint32, ) *types.VotingPowerDistCache { // a map where key is finality provider's BTC PK hex and value is a list // of BTC delegations that newly become active under this provider activeBTCDels := map[string][]*types.BTCDelegation{} // a map where key is unbonded BTC delegation's staking tx hash unbondedBTCDels := map[string]struct{}{} - // a map where key is slashed finality providers' BTC PK - slashedFPs := map[string]struct{}{} + // a map where key is slashed or jailed finality providers' BTC PK + slashedOrJailedFPs := map[string]struct{}{} /* filter and classify all events into new/expired BTC delegations and slashed FPs @@ -183,8 +182,11 @@ func (k Keeper) ProcessAllPowerDistUpdateEvents( unbondedBTCDels[delEvent.StakingTxHash] = struct{}{} } case *types.EventPowerDistUpdate_SlashedFp: - // slashed finality providers - slashedFPs[typedEvent.SlashedFp.Pk.MarshalHex()] = struct{}{} + // record slashed fps + slashedOrJailedFPs[typedEvent.SlashedFp.Pk.MarshalHex()] = struct{}{} + case *types.EventPowerDistUpdate_JailedFp: + // record jailed fps + slashedOrJailedFPs[typedEvent.JailedFp.Pk.MarshalHex()] = struct{}{} } } @@ -208,8 +210,9 @@ func (k Keeper) ProcessAllPowerDistUpdateEvents( fpBTCPKHex := fp.BtcPk.MarshalHex() - // if this finality provider is slashed, continue to avoid recording it - if _, ok := slashedFPs[fpBTCPKHex]; ok { + // if this finality provider is slashed or jailed, continue to avoid + // assigning voting power to it + if _, ok := slashedOrJailedFPs[fpBTCPKHex]; ok { continue } diff --git a/x/btcstaking/keeper/power_dist_change_test.go b/x/btcstaking/keeper/power_dist_change_test.go index 0277ad28c..5f6c8d42f 100644 --- a/x/btcstaking/keeper/power_dist_change_test.go +++ b/x/btcstaking/keeper/power_dist_change_test.go @@ -58,9 +58,9 @@ func FuzzProcessAllPowerDistUpdateEvents_Determinism(f *testing.F) { } } - newDc := h.BTCStakingKeeper.ProcessAllPowerDistUpdateEvents(h.Ctx, dc, events, 100) + newDc := h.BTCStakingKeeper.ProcessAllPowerDistUpdateEvents(h.Ctx, dc, events) for i := 0; i < 10; i++ { - newDc2 := h.BTCStakingKeeper.ProcessAllPowerDistUpdateEvents(h.Ctx, dc, events, 100) + newDc2 := h.BTCStakingKeeper.ProcessAllPowerDistUpdateEvents(h.Ctx, dc, events) require.Equal(t, newDc, newDc2) } }) diff --git a/x/btcstaking/types/btcstaking.go b/x/btcstaking/types/btcstaking.go index b7338a84f..b0b9648c7 100644 --- a/x/btcstaking/types/btcstaking.go +++ b/x/btcstaking/types/btcstaking.go @@ -17,8 +17,8 @@ func (fp *FinalityProvider) IsSlashed() bool { return fp.SlashedBabylonHeight > 0 } -func (fp *FinalityProvider) IsSluggish() bool { - return fp.Sluggish +func (fp *FinalityProvider) IsJailed() bool { + return fp.Jailed } func (fp *FinalityProvider) ValidateBasic() error { diff --git a/x/btcstaking/types/btcstaking.pb.go b/x/btcstaking/types/btcstaking.pb.go index 09e42a299..7e4c3d117 100644 --- a/x/btcstaking/types/btcstaking.pb.go +++ b/x/btcstaking/types/btcstaking.pb.go @@ -90,8 +90,8 @@ type FinalityProvider struct { // the finality provider is slashed. // if it's 0 then the finality provider is not slashed SlashedBtcHeight uint64 `protobuf:"varint,7,opt,name=slashed_btc_height,json=slashedBtcHeight,proto3" json:"slashed_btc_height,omitempty"` - // sluggish defines whether the finality provider is detected sluggish - Sluggish bool `protobuf:"varint,8,opt,name=sluggish,proto3" json:"sluggish,omitempty"` + // jailed defines whether the finality provider is jailed + Jailed bool `protobuf:"varint,8,opt,name=jailed,proto3" json:"jailed,omitempty"` } func (m *FinalityProvider) Reset() { *m = FinalityProvider{} } @@ -162,9 +162,9 @@ func (m *FinalityProvider) GetSlashedBtcHeight() uint64 { return 0 } -func (m *FinalityProvider) GetSluggish() bool { +func (m *FinalityProvider) GetJailed() bool { if m != nil { - return m.Sluggish + return m.Jailed } return false } @@ -186,8 +186,8 @@ type FinalityProviderWithMeta struct { // the finality provider is slashed. // if it's 0 then the finality provider is not slashed SlashedBtcHeight uint64 `protobuf:"varint,5,opt,name=slashed_btc_height,json=slashedBtcHeight,proto3" json:"slashed_btc_height,omitempty"` - // sluggish defines whether the finality provider is detected sluggish - Sluggish bool `protobuf:"varint,6,opt,name=sluggish,proto3" json:"sluggish,omitempty"` + // jailed defines whether the finality provider is detected jailed + Jailed bool `protobuf:"varint,6,opt,name=jailed,proto3" json:"jailed,omitempty"` } func (m *FinalityProviderWithMeta) Reset() { *m = FinalityProviderWithMeta{} } @@ -251,9 +251,9 @@ func (m *FinalityProviderWithMeta) GetSlashedBtcHeight() uint64 { return 0 } -func (m *FinalityProviderWithMeta) GetSluggish() bool { +func (m *FinalityProviderWithMeta) GetJailed() bool { if m != nil { - return m.Sluggish + return m.Jailed } return false } @@ -762,83 +762,83 @@ func init() { } var fileDescriptor_3851ae95ccfaf7db = []byte{ - // 1213 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xdf, 0x6e, 0x1a, 0xc7, - 0x17, 0xf6, 0x02, 0xc6, 0xf6, 0x01, 0x62, 0x32, 0x71, 0x9c, 0x8d, 0xad, 0x9f, 0xcd, 0x8f, 0xa6, - 0x11, 0x6a, 0x63, 0xc8, 0x3f, 0xa9, 0xa9, 0xaa, 0x5e, 0x18, 0xe3, 0x34, 0x56, 0x13, 0x4c, 0x17, - 0x9c, 0xaa, 0x95, 0xaa, 0xed, 0xb0, 0x3b, 0x2c, 0x23, 0x60, 0x67, 0xbb, 0x33, 0x50, 0xfc, 0x14, - 0xed, 0x0b, 0xf4, 0xb6, 0xea, 0x03, 0xe4, 0x21, 0x72, 0x19, 0xe5, 0xaa, 0xf2, 0x85, 0x55, 0x25, - 0x52, 0x5f, 0xa0, 0x2f, 0x50, 0xcd, 0xec, 0xb2, 0x2c, 0xae, 0x1d, 0x39, 0xb1, 0xef, 0x98, 0xf3, - 0xef, 0x3b, 0x73, 0xbe, 0x8f, 0x33, 0x0b, 0xb7, 0xdb, 0xb8, 0x7d, 0xd8, 0x67, 0x6e, 0xa5, 0x2d, - 0x2c, 0x2e, 0x70, 0x8f, 0xba, 0x4e, 0x65, 0x74, 0x2f, 0x76, 0x2a, 0x7b, 0x3e, 0x13, 0x0c, 0x5d, - 0x0f, 0xe3, 0xca, 0x31, 0xcf, 0xe8, 0xde, 0xda, 0x8a, 0xc3, 0x1c, 0xa6, 0x22, 0x2a, 0xf2, 0x57, - 0x10, 0xbc, 0x76, 0xd3, 0x62, 0x7c, 0xc0, 0xb8, 0x19, 0x38, 0x82, 0x43, 0xe8, 0xba, 0x15, 0x9c, - 0x2a, 0x53, 0xac, 0x36, 0x11, 0xf8, 0x5e, 0x65, 0x06, 0x6d, 0x6d, 0xf3, 0xf4, 0xae, 0x3c, 0xe6, - 0x05, 0x01, 0xc5, 0xbf, 0x93, 0x90, 0x7f, 0x4c, 0x5d, 0xdc, 0xa7, 0xe2, 0xb0, 0xe1, 0xb3, 0x11, - 0xb5, 0x89, 0x8f, 0xee, 0x40, 0x0a, 0xdb, 0xb6, 0xaf, 0x6b, 0x05, 0xad, 0xb4, 0x54, 0xd5, 0x5f, - 0xbf, 0xd8, 0x5a, 0x09, 0xb1, 0xb7, 0x6d, 0xdb, 0x27, 0x9c, 0x37, 0x85, 0x4f, 0x5d, 0xc7, 0x50, - 0x51, 0x68, 0x17, 0x32, 0x36, 0xe1, 0x96, 0x4f, 0x3d, 0x41, 0x99, 0xab, 0x27, 0x0a, 0x5a, 0x29, - 0x73, 0xff, 0xa3, 0x72, 0x98, 0x31, 0xbd, 0xa3, 0xea, 0xaf, 0x5c, 0x9b, 0x86, 0x1a, 0xf1, 0x3c, - 0xf4, 0x0c, 0xc0, 0x62, 0x83, 0x01, 0xe5, 0x5c, 0x56, 0x49, 0x2a, 0xe8, 0xad, 0xa3, 0xe3, 0xcd, - 0xf5, 0xa0, 0x10, 0xb7, 0x7b, 0x65, 0xca, 0x2a, 0x03, 0x2c, 0xba, 0xe5, 0xa7, 0xc4, 0xc1, 0xd6, - 0x61, 0x8d, 0x58, 0xaf, 0x5f, 0x6c, 0x41, 0x88, 0x53, 0x23, 0x96, 0x11, 0x2b, 0x80, 0xf6, 0x21, - 0xdd, 0x16, 0x96, 0xe9, 0xf5, 0xf4, 0x54, 0x41, 0x2b, 0x65, 0xab, 0x8f, 0x8e, 0x8e, 0x37, 0x1f, - 0x3a, 0x54, 0x74, 0x87, 0xed, 0xb2, 0xc5, 0x06, 0x95, 0x70, 0x30, 0x7d, 0xdc, 0xe6, 0x5b, 0x94, - 0x4d, 0x8e, 0x15, 0x71, 0xe8, 0x11, 0x5e, 0xae, 0xee, 0x35, 0x1e, 0x3c, 0xbc, 0xdb, 0x18, 0xb6, - 0xbf, 0x26, 0x87, 0xc6, 0x7c, 0x5b, 0x58, 0x8d, 0x1e, 0xfa, 0x12, 0x92, 0x1e, 0xf3, 0xf4, 0x79, - 0x75, 0xbd, 0x4f, 0xcb, 0xa7, 0xd2, 0x58, 0x6e, 0xf8, 0x8c, 0x75, 0xf6, 0x3b, 0x0d, 0xc6, 0x39, - 0x51, 0x7d, 0x54, 0x5b, 0x3b, 0x86, 0xcc, 0x43, 0x0f, 0x61, 0x95, 0xf7, 0x31, 0xef, 0x12, 0xdb, - 0x0c, 0x53, 0xcd, 0x2e, 0xa1, 0x4e, 0x57, 0xe8, 0xe9, 0x82, 0x56, 0x4a, 0x19, 0x2b, 0xa1, 0xb7, - 0x1a, 0x38, 0x9f, 0x28, 0x1f, 0xba, 0x03, 0x28, 0xca, 0x12, 0xd6, 0x24, 0x63, 0x41, 0x65, 0xe4, - 0x27, 0x19, 0xc2, 0x0a, 0xa3, 0xd7, 0x60, 0x91, 0xf7, 0x87, 0x8e, 0x43, 0x79, 0x57, 0x5f, 0x2c, - 0x68, 0xa5, 0x45, 0x23, 0x3a, 0x17, 0x7f, 0x4f, 0x80, 0x7e, 0x92, 0xe8, 0x6f, 0xa9, 0xe8, 0x3e, - 0x23, 0x02, 0xc7, 0x86, 0xa5, 0x5d, 0xce, 0xb0, 0x56, 0x21, 0x1d, 0xf6, 0x9a, 0x50, 0xbd, 0x86, - 0x27, 0xf4, 0x7f, 0xc8, 0x8e, 0x98, 0xa0, 0xae, 0x63, 0x7a, 0xec, 0x67, 0xe2, 0x2b, 0x9a, 0x53, - 0x46, 0x26, 0xb0, 0x35, 0xa4, 0xe9, 0x1d, 0x83, 0x4a, 0xbd, 0xf7, 0xa0, 0xe6, 0xcf, 0x31, 0xa8, - 0xf4, 0x89, 0x41, 0xfd, 0x93, 0x86, 0x5c, 0xb5, 0xb5, 0x53, 0x23, 0x7d, 0xe2, 0x60, 0xa5, 0xcc, - 0xcf, 0x21, 0x23, 0x29, 0x26, 0xbe, 0x79, 0xae, 0x7f, 0x05, 0x04, 0xc1, 0xd2, 0x18, 0x1b, 0x6c, - 0xe2, 0x52, 0x55, 0x98, 0xfc, 0x40, 0x15, 0xfe, 0x00, 0x57, 0x3a, 0x9e, 0x19, 0xb4, 0x64, 0xf6, - 0x29, 0x97, 0x43, 0x4d, 0x5e, 0xa8, 0xaf, 0x4c, 0xc7, 0xab, 0xca, 0xce, 0x9e, 0x52, 0xae, 0xe8, - 0xe5, 0x02, 0xfb, 0x62, 0x76, 0xfe, 0x19, 0x65, 0x0b, 0x47, 0xff, 0x3f, 0x00, 0xe2, 0xda, 0xb3, - 0xda, 0x5f, 0x22, 0xae, 0x1d, 0xba, 0xd7, 0x61, 0x49, 0x30, 0x81, 0xfb, 0x26, 0xc7, 0x13, 0x9d, - 0x2f, 0x2a, 0x43, 0x13, 0xab, 0xdc, 0xf0, 0x96, 0xa6, 0x18, 0x2b, 0x85, 0x67, 0x8d, 0xa5, 0xd0, - 0xd2, 0x1a, 0x2b, 0x0d, 0x84, 0x6e, 0x36, 0x14, 0xde, 0x50, 0x98, 0xd4, 0x1e, 0xeb, 0x4b, 0x05, - 0xad, 0x94, 0x33, 0xf2, 0xa1, 0x67, 0x5f, 0x39, 0xf6, 0xec, 0x31, 0xba, 0x0f, 0x19, 0xa5, 0x8b, - 0xb0, 0x1a, 0x28, 0x7e, 0xae, 0x1e, 0x1d, 0x6f, 0x4a, 0xf6, 0x9b, 0xa1, 0xa7, 0x35, 0x36, 0x80, - 0x47, 0xbf, 0xd1, 0x8f, 0x90, 0xb3, 0x03, 0x5d, 0x30, 0xdf, 0xe4, 0xd4, 0xd1, 0x33, 0x2a, 0xeb, - 0x8b, 0xa3, 0xe3, 0xcd, 0xcf, 0xde, 0x6f, 0x7a, 0x4d, 0xea, 0xb8, 0x58, 0x0c, 0x7d, 0x62, 0x64, - 0xa3, 0x8a, 0x4d, 0xea, 0xa0, 0x03, 0xc8, 0x59, 0x6c, 0x44, 0x5c, 0xec, 0x0a, 0x09, 0xc0, 0xf5, - 0x6c, 0x21, 0x59, 0xca, 0xdc, 0xbf, 0x7b, 0x06, 0xd3, 0x3b, 0x61, 0xec, 0xb6, 0x8d, 0xbd, 0xa0, - 0x42, 0x50, 0x95, 0x1b, 0xd9, 0x49, 0x99, 0x26, 0x75, 0x38, 0xfa, 0x18, 0xae, 0x0c, 0xdd, 0x36, - 0x73, 0x6d, 0x75, 0x5b, 0x3a, 0x20, 0x7a, 0x4e, 0x8d, 0x25, 0x17, 0x59, 0x5b, 0x74, 0x40, 0xd0, - 0x37, 0x90, 0x97, 0xda, 0x18, 0xba, 0x76, 0xa4, 0x7e, 0xfd, 0x8a, 0x92, 0xda, 0xed, 0x33, 0x1a, - 0xa8, 0xb6, 0x76, 0x0e, 0x62, 0xd1, 0xc6, 0x72, 0x5b, 0x58, 0x71, 0x83, 0x44, 0xf6, 0xb0, 0x8f, - 0x07, 0xdc, 0x1c, 0x11, 0x5f, 0xad, 0xf6, 0xe5, 0x00, 0x39, 0xb0, 0x3e, 0x0f, 0x8c, 0xc5, 0xdf, - 0x52, 0xb0, 0x7c, 0xa2, 0x96, 0x54, 0x53, 0xac, 0xe9, 0x71, 0xb0, 0x9b, 0x8c, 0xcc, 0xb4, 0xe5, - 0xff, 0x90, 0x98, 0x38, 0x0f, 0x89, 0x1c, 0x6e, 0x4c, 0x49, 0x9c, 0x02, 0x48, 0x3a, 0x93, 0x17, - 0xa7, 0xf3, 0x7a, 0x54, 0xfb, 0x60, 0x52, 0x5a, 0xf2, 0xfa, 0x13, 0xac, 0xc6, 0x94, 0x33, 0x69, - 0x59, 0x62, 0xa6, 0x2e, 0x8e, 0xb9, 0x32, 0x95, 0x50, 0x58, 0x59, 0x42, 0x76, 0x60, 0x75, 0x2a, - 0xa5, 0x18, 0x22, 0xd7, 0xe7, 0x3f, 0x50, 0x53, 0x2b, 0x91, 0xa6, 0xa6, 0x30, 0x1c, 0x59, 0xb0, - 0x1e, 0xe1, 0xcc, 0x8c, 0x33, 0x58, 0x30, 0x69, 0x05, 0x76, 0xeb, 0x0c, 0xb0, 0xa8, 0xfa, 0x9e, - 0xdb, 0x61, 0x86, 0x3e, 0x29, 0x14, 0x9f, 0x9d, 0xdc, 0x2c, 0xc5, 0x26, 0xdc, 0x98, 0x2e, 0x65, - 0xe6, 0x4f, 0xb7, 0x33, 0x47, 0x8f, 0x20, 0x65, 0x93, 0x3e, 0xd7, 0xb5, 0x77, 0x02, 0xcd, 0xac, - 0x74, 0x43, 0x65, 0x14, 0xeb, 0xb0, 0x7e, 0x7a, 0xd1, 0x3d, 0xd7, 0x26, 0x63, 0x54, 0x81, 0x95, - 0xe9, 0xba, 0x31, 0xbb, 0x98, 0x77, 0x83, 0x1b, 0x49, 0xa0, 0xac, 0x71, 0x35, 0x5a, 0x3c, 0x4f, - 0x30, 0xef, 0xaa, 0x26, 0xff, 0xd0, 0x20, 0x37, 0x73, 0x21, 0xf4, 0x04, 0x12, 0x97, 0xf0, 0xa8, - 0x26, 0xbc, 0x1e, 0x7a, 0x06, 0x49, 0xa9, 0x96, 0xc4, 0xc5, 0xd5, 0x22, 0xeb, 0x14, 0x7f, 0xd1, - 0xe0, 0xe6, 0x99, 0x44, 0xcb, 0x67, 0xcb, 0x62, 0xa3, 0x4b, 0xf9, 0x1e, 0xb0, 0xd8, 0xa8, 0xd1, - 0x93, 0x7f, 0x65, 0x1c, 0xa0, 0x04, 0x0a, 0x4c, 0xa8, 0x11, 0x66, 0x70, 0x84, 0xcc, 0x8b, 0x2f, - 0x35, 0xb8, 0xd9, 0x24, 0x7d, 0x62, 0x09, 0x3a, 0x22, 0x13, 0x81, 0xed, 0xca, 0xef, 0x14, 0xd7, - 0x22, 0xe8, 0x36, 0x2c, 0x9f, 0xe0, 0x22, 0x78, 0x87, 0x8d, 0xdc, 0x0c, 0x0d, 0xa8, 0x05, 0x4b, - 0xd1, 0x03, 0x77, 0xe1, 0x37, 0x77, 0x21, 0x7c, 0xdb, 0xd0, 0x16, 0x5c, 0xf3, 0x89, 0xd4, 0xa6, - 0x4f, 0x6c, 0x33, 0xac, 0xcf, 0x7b, 0xc1, 0xba, 0x30, 0xf2, 0x91, 0xeb, 0xb1, 0x0c, 0x6f, 0xf6, - 0x3e, 0xd9, 0x85, 0x6b, 0x33, 0x72, 0x6b, 0x0a, 0x2c, 0x86, 0x1c, 0x65, 0x60, 0xa1, 0xb1, 0x5b, - 0xaf, 0xed, 0xd5, 0xbf, 0xca, 0xcf, 0x21, 0x80, 0xf4, 0xf6, 0x4e, 0x6b, 0xef, 0xf9, 0x6e, 0x5e, - 0x43, 0x59, 0x58, 0x3c, 0xa8, 0x57, 0xf7, 0xeb, 0xb5, 0xdd, 0x5a, 0x3e, 0x81, 0x16, 0x20, 0xb9, - 0x5d, 0xff, 0x2e, 0x9f, 0xac, 0xd6, 0x5f, 0xbe, 0xd9, 0xd0, 0x5e, 0xbd, 0xd9, 0xd0, 0xfe, 0x7a, - 0xb3, 0xa1, 0xfd, 0xfa, 0x76, 0x63, 0xee, 0xd5, 0xdb, 0x8d, 0xb9, 0x3f, 0xdf, 0x6e, 0xcc, 0x7d, - 0x7f, 0x8e, 0xeb, 0x8c, 0xe3, 0x9f, 0xfc, 0xea, 0x6e, 0xed, 0xb4, 0xfa, 0xe4, 0x7f, 0xf0, 0x6f, - 0x00, 0x00, 0x00, 0xff, 0xff, 0x12, 0x9b, 0x63, 0xae, 0xab, 0x0c, 0x00, 0x00, + // 1209 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xdd, 0x6e, 0x1b, 0x45, + 0x14, 0xce, 0xda, 0x8e, 0x93, 0x1c, 0xdb, 0x8d, 0x3b, 0x4d, 0xd3, 0x6d, 0x23, 0x12, 0x63, 0x4a, + 0x65, 0x41, 0x63, 0xf7, 0x4f, 0xa2, 0x08, 0x71, 0x11, 0xc7, 0x29, 0x8d, 0x68, 0x1d, 0xb3, 0x76, + 0x8a, 0x40, 0x42, 0xcb, 0x78, 0x77, 0xb2, 0x1e, 0x6c, 0xef, 0x2c, 0x3b, 0x63, 0xe3, 0x3c, 0x05, + 0xbc, 0x00, 0x37, 0x5c, 0xf1, 0x00, 0x7d, 0x88, 0x5e, 0x56, 0xbd, 0x42, 0xb9, 0x88, 0x50, 0xfa, + 0x08, 0xbc, 0x00, 0x9a, 0xd9, 0xf5, 0xee, 0xba, 0x34, 0xa5, 0x6d, 0x72, 0xe7, 0x39, 0x7f, 0xdf, + 0x99, 0xf3, 0x7d, 0x3e, 0xb3, 0x70, 0xa3, 0x8b, 0xbb, 0x87, 0x03, 0xe6, 0xd6, 0xba, 0xc2, 0xe2, + 0x02, 0xf7, 0xa9, 0xeb, 0xd4, 0xc6, 0xb7, 0x13, 0xa7, 0xaa, 0xe7, 0x33, 0xc1, 0xd0, 0xe5, 0x30, + 0xae, 0x9a, 0xf0, 0x8c, 0x6f, 0x5f, 0x5b, 0x71, 0x98, 0xc3, 0x54, 0x44, 0x4d, 0xfe, 0x0a, 0x82, + 0xaf, 0x5d, 0xb5, 0x18, 0x1f, 0x32, 0x6e, 0x06, 0x8e, 0xe0, 0x10, 0xba, 0xae, 0x07, 0xa7, 0x5a, + 0x8c, 0xd5, 0x25, 0x02, 0xdf, 0xae, 0xcd, 0xa0, 0x5d, 0xdb, 0x78, 0x7d, 0x57, 0x1e, 0xf3, 0x82, + 0x80, 0xf2, 0x49, 0x1a, 0x8a, 0x0f, 0xa8, 0x8b, 0x07, 0x54, 0x1c, 0xb6, 0x7c, 0x36, 0xa6, 0x36, + 0xf1, 0xd1, 0x4d, 0xc8, 0x60, 0xdb, 0xf6, 0x75, 0xad, 0xa4, 0x55, 0x96, 0xea, 0xfa, 0x8b, 0xa7, + 0x9b, 0x2b, 0x21, 0xf6, 0x96, 0x6d, 0xfb, 0x84, 0xf3, 0xb6, 0xf0, 0xa9, 0xeb, 0x18, 0x2a, 0x0a, + 0xed, 0x40, 0xce, 0x26, 0xdc, 0xf2, 0xa9, 0x27, 0x28, 0x73, 0xf5, 0x54, 0x49, 0xab, 0xe4, 0xee, + 0x7c, 0x54, 0x0d, 0x33, 0xe2, 0x3b, 0xaa, 0xfe, 0xaa, 0x8d, 0x38, 0xd4, 0x48, 0xe6, 0xa1, 0xc7, + 0x00, 0x16, 0x1b, 0x0e, 0x29, 0xe7, 0xb2, 0x4a, 0x5a, 0x41, 0x6f, 0x1e, 0x1d, 0x6f, 0xac, 0x05, + 0x85, 0xb8, 0xdd, 0xaf, 0x52, 0x56, 0x1b, 0x62, 0xd1, 0xab, 0x3e, 0x22, 0x0e, 0xb6, 0x0e, 0x1b, + 0xc4, 0x7a, 0xf1, 0x74, 0x13, 0x42, 0x9c, 0x06, 0xb1, 0x8c, 0x44, 0x01, 0xb4, 0x07, 0xd9, 0xae, + 0xb0, 0x4c, 0xaf, 0xaf, 0x67, 0x4a, 0x5a, 0x25, 0x5f, 0xbf, 0x7f, 0x74, 0xbc, 0x71, 0xcf, 0xa1, + 0xa2, 0x37, 0xea, 0x56, 0x2d, 0x36, 0xac, 0x85, 0x83, 0x19, 0xe0, 0x2e, 0xdf, 0xa4, 0x6c, 0x7a, + 0xac, 0x89, 0x43, 0x8f, 0xf0, 0x6a, 0x7d, 0xb7, 0x75, 0xf7, 0xde, 0xad, 0xd6, 0xa8, 0xfb, 0x35, + 0x39, 0x34, 0xe6, 0xbb, 0xc2, 0x6a, 0xf5, 0xd1, 0x97, 0x90, 0xf6, 0x98, 0xa7, 0xcf, 0xab, 0xeb, + 0x7d, 0x5a, 0x7d, 0x2d, 0x8d, 0xd5, 0x96, 0xcf, 0xd8, 0xc1, 0xde, 0x41, 0x8b, 0x71, 0x4e, 0x54, + 0x1f, 0xf5, 0xce, 0xb6, 0x21, 0xf3, 0xd0, 0x3d, 0x58, 0xe5, 0x03, 0xcc, 0x7b, 0xc4, 0x36, 0xc3, + 0x54, 0xb3, 0x47, 0xa8, 0xd3, 0x13, 0x7a, 0xb6, 0xa4, 0x55, 0x32, 0xc6, 0x4a, 0xe8, 0xad, 0x07, + 0xce, 0x87, 0xca, 0x87, 0x6e, 0x02, 0x8a, 0xb2, 0x84, 0x35, 0xcd, 0x58, 0x50, 0x19, 0xc5, 0x69, + 0x86, 0xb0, 0xc2, 0xe8, 0x55, 0xc8, 0xfe, 0x84, 0xe9, 0x80, 0xd8, 0xfa, 0x62, 0x49, 0xab, 0x2c, + 0x1a, 0xe1, 0xa9, 0xfc, 0x47, 0x0a, 0xf4, 0x57, 0x49, 0xfe, 0x96, 0x8a, 0xde, 0x63, 0x22, 0x70, + 0x62, 0x50, 0xda, 0xf9, 0x0c, 0x6a, 0x15, 0xb2, 0x61, 0x9f, 0x29, 0xd5, 0x67, 0x78, 0x42, 0x1f, + 0x42, 0x7e, 0xcc, 0x04, 0x75, 0x1d, 0xd3, 0x63, 0xbf, 0x10, 0x5f, 0x51, 0x9c, 0x31, 0x72, 0x81, + 0xad, 0x25, 0x4d, 0x6f, 0x18, 0x52, 0xe6, 0x9d, 0x87, 0x34, 0xff, 0xbf, 0x43, 0xca, 0xce, 0x0c, + 0xe9, 0x9f, 0x2c, 0x14, 0xea, 0x9d, 0xed, 0x06, 0x19, 0x10, 0x07, 0x2b, 0x45, 0x7e, 0x0e, 0x39, + 0x49, 0x2d, 0xf1, 0xcd, 0xb7, 0xfa, 0x37, 0x40, 0x10, 0x2c, 0x8d, 0x89, 0xa1, 0xa6, 0xce, 0x55, + 0x7d, 0xe9, 0xf7, 0x54, 0xdf, 0x0f, 0x70, 0xe1, 0xc0, 0x33, 0x83, 0x96, 0xcc, 0x01, 0xe5, 0x72, + 0xa0, 0xe9, 0x33, 0xf5, 0x95, 0x3b, 0xf0, 0xea, 0xb2, 0xb3, 0x47, 0x94, 0x2b, 0x6a, 0xb9, 0xc0, + 0xbe, 0x98, 0x9d, 0x7d, 0x4e, 0xd9, 0xc2, 0xb1, 0x7f, 0x00, 0x40, 0x5c, 0x7b, 0x56, 0xf3, 0x4b, + 0xc4, 0xb5, 0x43, 0xf7, 0x1a, 0x2c, 0x09, 0x26, 0xf0, 0xc0, 0xe4, 0x78, 0xaa, 0xef, 0x45, 0x65, + 0x68, 0x63, 0x95, 0x1b, 0xde, 0xd2, 0x14, 0x13, 0xa5, 0xed, 0xbc, 0xb1, 0x14, 0x5a, 0x3a, 0x13, + 0xc5, 0x7f, 0xe8, 0x66, 0x23, 0xe1, 0x8d, 0x84, 0x49, 0xed, 0x89, 0xbe, 0x54, 0xd2, 0x2a, 0x05, + 0xa3, 0x18, 0x7a, 0xf6, 0x94, 0x63, 0xd7, 0x9e, 0xa0, 0x3b, 0x90, 0x53, 0x9a, 0x08, 0xab, 0x81, + 0xe2, 0xe7, 0xe2, 0xd1, 0xf1, 0x86, 0x64, 0xbf, 0x1d, 0x7a, 0x3a, 0x13, 0x03, 0x78, 0xf4, 0x1b, + 0xfd, 0x08, 0x05, 0x3b, 0xd0, 0x05, 0xf3, 0x4d, 0x4e, 0x1d, 0x3d, 0xa7, 0xb2, 0xbe, 0x38, 0x3a, + 0xde, 0xf8, 0xec, 0xdd, 0xa6, 0xd7, 0xa6, 0x8e, 0x8b, 0xc5, 0xc8, 0x27, 0x46, 0x3e, 0xaa, 0xd8, + 0xa6, 0x0e, 0xda, 0x87, 0x82, 0xc5, 0xc6, 0xc4, 0xc5, 0xae, 0x90, 0x00, 0x5c, 0xcf, 0x97, 0xd2, + 0x95, 0xdc, 0x9d, 0x5b, 0xa7, 0x30, 0xbd, 0x1d, 0xc6, 0x6e, 0xd9, 0xd8, 0x0b, 0x2a, 0x04, 0x55, + 0xb9, 0x91, 0x9f, 0x96, 0x69, 0x53, 0x87, 0xa3, 0x8f, 0xe1, 0xc2, 0xc8, 0xed, 0x32, 0xd7, 0x56, + 0xb7, 0xa5, 0x43, 0xa2, 0x17, 0xd4, 0x58, 0x0a, 0x91, 0xb5, 0x43, 0x87, 0x04, 0x7d, 0x03, 0x45, + 0xa9, 0x8d, 0x91, 0x6b, 0x47, 0xea, 0xd7, 0x2f, 0x28, 0xa9, 0xdd, 0x38, 0xa5, 0x81, 0x7a, 0x67, + 0x7b, 0x3f, 0x11, 0x6d, 0x2c, 0x77, 0x85, 0x95, 0x34, 0x48, 0x64, 0x0f, 0xfb, 0x78, 0xc8, 0xcd, + 0x31, 0xf1, 0xd5, 0x4a, 0x5f, 0x0e, 0x90, 0x03, 0xeb, 0x93, 0xc0, 0x58, 0xfe, 0x3d, 0x03, 0xcb, + 0xaf, 0xd4, 0x92, 0x6a, 0x4a, 0x34, 0x3d, 0x09, 0xf6, 0x92, 0x91, 0x8b, 0x5b, 0xfe, 0x0f, 0x89, + 0xa9, 0xb7, 0x21, 0x91, 0xc3, 0x95, 0x98, 0xc4, 0x18, 0x40, 0xd2, 0x99, 0x3e, 0x3b, 0x9d, 0x97, + 0xa3, 0xda, 0xfb, 0xd3, 0xd2, 0x92, 0xd7, 0x9f, 0x61, 0x35, 0xa1, 0x9c, 0x69, 0xcb, 0x12, 0x33, + 0x73, 0x76, 0xcc, 0x95, 0x58, 0x42, 0x61, 0x65, 0x09, 0x79, 0x00, 0xab, 0xb1, 0x94, 0x12, 0x88, + 0x5c, 0x9f, 0x7f, 0x4f, 0x4d, 0xad, 0x44, 0x9a, 0x8a, 0x61, 0x38, 0xb2, 0x60, 0x2d, 0xc2, 0x99, + 0x19, 0x67, 0xb0, 0x60, 0xb2, 0x0a, 0xec, 0xfa, 0x29, 0x60, 0x51, 0xf5, 0x5d, 0xf7, 0x80, 0x19, + 0xfa, 0xb4, 0x50, 0x72, 0x76, 0x72, 0xb3, 0x94, 0xdb, 0x70, 0x25, 0x5e, 0xca, 0xcc, 0x8f, 0xb7, + 0x33, 0x47, 0xf7, 0x21, 0x63, 0x93, 0x01, 0xd7, 0xb5, 0x37, 0x02, 0xcd, 0xac, 0x74, 0x43, 0x65, + 0x94, 0x9b, 0xb0, 0xf6, 0xfa, 0xa2, 0xbb, 0xae, 0x4d, 0x26, 0xa8, 0x06, 0x2b, 0xf1, 0xba, 0x31, + 0x7b, 0x98, 0xf7, 0x82, 0x1b, 0x49, 0xa0, 0xbc, 0x71, 0x31, 0x5a, 0x3c, 0x0f, 0x31, 0xef, 0xa9, + 0x26, 0xff, 0xd4, 0xa0, 0x30, 0x73, 0x21, 0xf4, 0x10, 0x52, 0xe7, 0xf0, 0xa0, 0xa6, 0xbc, 0x3e, + 0x7a, 0x0c, 0x69, 0xa9, 0x96, 0xd4, 0xd9, 0xd5, 0x22, 0xeb, 0x94, 0x7f, 0xd5, 0xe0, 0xea, 0xa9, + 0x44, 0xcb, 0x67, 0xcb, 0x62, 0xe3, 0x73, 0xf9, 0x16, 0xb0, 0xd8, 0xb8, 0xd5, 0x97, 0x7f, 0x65, + 0x1c, 0xa0, 0x04, 0x0a, 0x4c, 0xa9, 0x11, 0xe6, 0x70, 0x84, 0xcc, 0xcb, 0xcf, 0x34, 0xb8, 0xda, + 0x26, 0x03, 0x62, 0x09, 0x3a, 0x26, 0x53, 0x81, 0xed, 0xc8, 0x6f, 0x14, 0xd7, 0x22, 0xe8, 0x06, + 0x2c, 0xbf, 0xc2, 0x45, 0xf0, 0x0e, 0x1b, 0x85, 0x19, 0x1a, 0x50, 0x07, 0x96, 0xa2, 0x07, 0xee, + 0xcc, 0x6f, 0xee, 0x42, 0xf8, 0xb6, 0xa1, 0x4d, 0xb8, 0xe4, 0x13, 0xa9, 0x4d, 0x9f, 0xd8, 0x66, + 0x58, 0x9f, 0xf7, 0x83, 0x75, 0x61, 0x14, 0x23, 0xd7, 0x03, 0x19, 0xde, 0xee, 0x7f, 0xb2, 0x03, + 0x97, 0x66, 0xe4, 0xd6, 0x16, 0x58, 0x8c, 0x38, 0xca, 0xc1, 0x42, 0x6b, 0xa7, 0xd9, 0xd8, 0x6d, + 0x7e, 0x55, 0x9c, 0x43, 0x00, 0xd9, 0xad, 0xed, 0xce, 0xee, 0x93, 0x9d, 0xa2, 0x86, 0xf2, 0xb0, + 0xb8, 0xdf, 0xac, 0xef, 0x35, 0x1b, 0x3b, 0x8d, 0x62, 0x0a, 0x2d, 0x40, 0x7a, 0xab, 0xf9, 0x5d, + 0x31, 0x5d, 0x6f, 0x3e, 0x3b, 0x59, 0xd7, 0x9e, 0x9f, 0xac, 0x6b, 0x7f, 0x9f, 0xac, 0x6b, 0xbf, + 0xbd, 0x5c, 0x9f, 0x7b, 0xfe, 0x72, 0x7d, 0xee, 0xaf, 0x97, 0xeb, 0x73, 0xdf, 0xbf, 0xc5, 0x75, + 0x26, 0xc9, 0x4f, 0x7d, 0x75, 0xb7, 0x6e, 0x56, 0x7d, 0xea, 0xdf, 0xfd, 0x37, 0x00, 0x00, 0xff, + 0xff, 0x16, 0x6d, 0xf3, 0xe5, 0xa3, 0x0c, 0x00, 0x00, } func (m *FinalityProvider) Marshal() (dAtA []byte, err error) { @@ -861,9 +861,9 @@ func (m *FinalityProvider) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - if m.Sluggish { + if m.Jailed { i-- - if m.Sluggish { + if m.Jailed { dAtA[i] = 1 } else { dAtA[i] = 0 @@ -959,9 +959,9 @@ func (m *FinalityProviderWithMeta) MarshalToSizedBuffer(dAtA []byte) (int, error _ = i var l int _ = l - if m.Sluggish { + if m.Jailed { i-- - if m.Sluggish { + if m.Jailed { dAtA[i] = 1 } else { dAtA[i] = 0 @@ -1505,7 +1505,7 @@ func (m *FinalityProvider) Size() (n int) { if m.SlashedBtcHeight != 0 { n += 1 + sovBtcstaking(uint64(m.SlashedBtcHeight)) } - if m.Sluggish { + if m.Jailed { n += 2 } return n @@ -1533,7 +1533,7 @@ func (m *FinalityProviderWithMeta) Size() (n int) { if m.SlashedBtcHeight != 0 { n += 1 + sovBtcstaking(uint64(m.SlashedBtcHeight)) } - if m.Sluggish { + if m.Jailed { n += 2 } return n @@ -1980,7 +1980,7 @@ func (m *FinalityProvider) Unmarshal(dAtA []byte) error { } case 8: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Sluggish", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Jailed", wireType) } var v int for shift := uint(0); ; shift += 7 { @@ -1997,7 +1997,7 @@ func (m *FinalityProvider) Unmarshal(dAtA []byte) error { break } } - m.Sluggish = bool(v != 0) + m.Jailed = bool(v != 0) default: iNdEx = preIndex skippy, err := skipBtcstaking(dAtA[iNdEx:]) @@ -2161,7 +2161,7 @@ func (m *FinalityProviderWithMeta) Unmarshal(dAtA []byte) error { } case 6: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Sluggish", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Jailed", wireType) } var v int for shift := uint(0); ; shift += 7 { @@ -2178,7 +2178,7 @@ func (m *FinalityProviderWithMeta) Unmarshal(dAtA []byte) error { break } } - m.Sluggish = bool(v != 0) + m.Jailed = bool(v != 0) default: iNdEx = preIndex skippy, err := skipBtcstaking(dAtA[iNdEx:]) diff --git a/x/btcstaking/types/errors.go b/x/btcstaking/types/errors.go index ffca7d9ab..3a47fa509 100644 --- a/x/btcstaking/types/errors.go +++ b/x/btcstaking/types/errors.go @@ -30,4 +30,5 @@ var ( ErrVotingPowerTableNotUpdated = errorsmod.Register(ModuleName, 1122, "voting power table has not been updated") ErrVotingPowerDistCacheNotFound = errorsmod.Register(ModuleName, 1123, "the voting power distribution cache is not found") ErrParamsNotFound = errorsmod.Register(ModuleName, 1124, "the parameters are not found") + ErrFpAlreadyJailed = errorsmod.Register(ModuleName, 1125, "the finality provider has already been jailed") ) diff --git a/x/btcstaking/types/events.go b/x/btcstaking/types/events.go index a87dbf10e..e3c92c493 100644 --- a/x/btcstaking/types/events.go +++ b/x/btcstaking/types/events.go @@ -21,3 +21,13 @@ func NewEventPowerDistUpdateWithSlashedFP(fpBTCPK *bbn.BIP340PubKey) *EventPower }, } } + +func NewEventPowerDistUpdateWithJailedFP(fpBTCPK *bbn.BIP340PubKey) *EventPowerDistUpdate { + return &EventPowerDistUpdate{ + Ev: &EventPowerDistUpdate_JailedFp{ + JailedFp: &EventPowerDistUpdate_EventJailedFinalityProvider{ + Pk: fpBTCPK, + }, + }, + } +} diff --git a/x/btcstaking/types/events.pb.go b/x/btcstaking/types/events.pb.go index c945e1f8d..e3c68fbb4 100644 --- a/x/btcstaking/types/events.pb.go +++ b/x/btcstaking/types/events.pb.go @@ -184,6 +184,7 @@ type EventPowerDistUpdate struct { // // Types that are valid to be assigned to Ev: // *EventPowerDistUpdate_SlashedFp + // *EventPowerDistUpdate_JailedFp // *EventPowerDistUpdate_BtcDelStateUpdate Ev isEventPowerDistUpdate_Ev `protobuf_oneof:"ev"` } @@ -230,11 +231,15 @@ type isEventPowerDistUpdate_Ev interface { type EventPowerDistUpdate_SlashedFp struct { SlashedFp *EventPowerDistUpdate_EventSlashedFinalityProvider `protobuf:"bytes,1,opt,name=slashed_fp,json=slashedFp,proto3,oneof" json:"slashed_fp,omitempty"` } +type EventPowerDistUpdate_JailedFp struct { + JailedFp *EventPowerDistUpdate_EventJailedFinalityProvider `protobuf:"bytes,2,opt,name=jailed_fp,json=jailedFp,proto3,oneof" json:"jailed_fp,omitempty"` +} type EventPowerDistUpdate_BtcDelStateUpdate struct { - BtcDelStateUpdate *EventBTCDelegationStateUpdate `protobuf:"bytes,2,opt,name=btc_del_state_update,json=btcDelStateUpdate,proto3,oneof" json:"btc_del_state_update,omitempty"` + BtcDelStateUpdate *EventBTCDelegationStateUpdate `protobuf:"bytes,3,opt,name=btc_del_state_update,json=btcDelStateUpdate,proto3,oneof" json:"btc_del_state_update,omitempty"` } func (*EventPowerDistUpdate_SlashedFp) isEventPowerDistUpdate_Ev() {} +func (*EventPowerDistUpdate_JailedFp) isEventPowerDistUpdate_Ev() {} func (*EventPowerDistUpdate_BtcDelStateUpdate) isEventPowerDistUpdate_Ev() {} func (m *EventPowerDistUpdate) GetEv() isEventPowerDistUpdate_Ev { @@ -251,6 +256,13 @@ func (m *EventPowerDistUpdate) GetSlashedFp() *EventPowerDistUpdate_EventSlashed return nil } +func (m *EventPowerDistUpdate) GetJailedFp() *EventPowerDistUpdate_EventJailedFinalityProvider { + if x, ok := m.GetEv().(*EventPowerDistUpdate_JailedFp); ok { + return x.JailedFp + } + return nil +} + func (m *EventPowerDistUpdate) GetBtcDelStateUpdate() *EventBTCDelegationStateUpdate { if x, ok := m.GetEv().(*EventPowerDistUpdate_BtcDelStateUpdate); ok { return x.BtcDelStateUpdate @@ -262,6 +274,7 @@ func (m *EventPowerDistUpdate) GetBtcDelStateUpdate() *EventBTCDelegationStateUp func (*EventPowerDistUpdate) XXX_OneofWrappers() []interface{} { return []interface{}{ (*EventPowerDistUpdate_SlashedFp)(nil), + (*EventPowerDistUpdate_JailedFp)(nil), (*EventPowerDistUpdate_BtcDelStateUpdate)(nil), } } @@ -310,12 +323,56 @@ func (m *EventPowerDistUpdate_EventSlashedFinalityProvider) XXX_DiscardUnknown() var xxx_messageInfo_EventPowerDistUpdate_EventSlashedFinalityProvider proto.InternalMessageInfo +// EventJailedFinalityProvider defines an event that a finality provider +// is jailed +type EventPowerDistUpdate_EventJailedFinalityProvider struct { + Pk *github_com_babylonlabs_io_babylon_types.BIP340PubKey `protobuf:"bytes,1,opt,name=pk,proto3,customtype=github.com/babylonlabs-io/babylon/types.BIP340PubKey" json:"pk,omitempty"` +} + +func (m *EventPowerDistUpdate_EventJailedFinalityProvider) Reset() { + *m = EventPowerDistUpdate_EventJailedFinalityProvider{} +} +func (m *EventPowerDistUpdate_EventJailedFinalityProvider) String() string { + return proto.CompactTextString(m) +} +func (*EventPowerDistUpdate_EventJailedFinalityProvider) ProtoMessage() {} +func (*EventPowerDistUpdate_EventJailedFinalityProvider) Descriptor() ([]byte, []int) { + return fileDescriptor_74118427820fff75, []int{3, 1} +} +func (m *EventPowerDistUpdate_EventJailedFinalityProvider) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventPowerDistUpdate_EventJailedFinalityProvider) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventPowerDistUpdate_EventJailedFinalityProvider.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *EventPowerDistUpdate_EventJailedFinalityProvider) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventPowerDistUpdate_EventJailedFinalityProvider.Merge(m, src) +} +func (m *EventPowerDistUpdate_EventJailedFinalityProvider) XXX_Size() int { + return m.Size() +} +func (m *EventPowerDistUpdate_EventJailedFinalityProvider) XXX_DiscardUnknown() { + xxx_messageInfo_EventPowerDistUpdate_EventJailedFinalityProvider.DiscardUnknown(m) +} + +var xxx_messageInfo_EventPowerDistUpdate_EventJailedFinalityProvider proto.InternalMessageInfo + func init() { proto.RegisterType((*EventNewFinalityProvider)(nil), "babylon.btcstaking.v1.EventNewFinalityProvider") proto.RegisterType((*EventBTCDelegationStateUpdate)(nil), "babylon.btcstaking.v1.EventBTCDelegationStateUpdate") proto.RegisterType((*EventSelectiveSlashing)(nil), "babylon.btcstaking.v1.EventSelectiveSlashing") proto.RegisterType((*EventPowerDistUpdate)(nil), "babylon.btcstaking.v1.EventPowerDistUpdate") proto.RegisterType((*EventPowerDistUpdate_EventSlashedFinalityProvider)(nil), "babylon.btcstaking.v1.EventPowerDistUpdate.EventSlashedFinalityProvider") + proto.RegisterType((*EventPowerDistUpdate_EventJailedFinalityProvider)(nil), "babylon.btcstaking.v1.EventPowerDistUpdate.EventJailedFinalityProvider") } func init() { @@ -323,37 +380,39 @@ func init() { } var fileDescriptor_74118427820fff75 = []byte{ - // 466 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xcd, 0x6e, 0xd3, 0x40, - 0x14, 0x85, 0x6d, 0x0b, 0xa1, 0x66, 0xca, 0x8f, 0xb0, 0x02, 0x8a, 0x22, 0x30, 0x95, 0x17, 0xa5, - 0x42, 0xc2, 0x6e, 0xd3, 0x48, 0xb0, 0x36, 0x69, 0x31, 0x02, 0x55, 0x91, 0x5d, 0x36, 0x6c, 0xac, - 0x19, 0xe7, 0xc6, 0x1e, 0xc5, 0xcc, 0x58, 0x99, 0x89, 0x93, 0xbc, 0x45, 0x1f, 0x8b, 0x65, 0x97, - 0xa8, 0x0b, 0x84, 0x92, 0x17, 0x41, 0x9e, 0x0c, 0x25, 0x6a, 0x93, 0xaa, 0xbb, 0xe4, 0xea, 0x9c, - 0xf3, 0x9d, 0x7b, 0xad, 0x41, 0x2e, 0xc1, 0x64, 0x5e, 0x70, 0xe6, 0x13, 0x99, 0x0a, 0x89, 0x47, - 0x94, 0x65, 0x7e, 0x75, 0xe4, 0x43, 0x05, 0x4c, 0x0a, 0xaf, 0x1c, 0x73, 0xc9, 0xed, 0xe7, 0x5a, - 0xe3, 0xfd, 0xd7, 0x78, 0xd5, 0x51, 0xbb, 0x99, 0xf1, 0x8c, 0x2b, 0x85, 0x5f, 0xff, 0x5a, 0x89, - 0xdb, 0xfb, 0x9b, 0x03, 0xd7, 0xac, 0x4a, 0xe7, 0xc6, 0xa8, 0x75, 0x52, 0x43, 0xce, 0x60, 0x7a, - 0x4a, 0x19, 0x2e, 0xa8, 0x9c, 0xf7, 0xc7, 0xbc, 0xa2, 0x03, 0x18, 0xdb, 0xef, 0x91, 0x35, 0x2c, - 0x5b, 0xe6, 0x9e, 0x79, 0xb0, 0xdb, 0x79, 0xe3, 0x6d, 0xa4, 0x7b, 0x37, 0x4d, 0x91, 0x35, 0x2c, - 0xdd, 0x0b, 0x13, 0xbd, 0x52, 0xa9, 0xc1, 0xf9, 0xc7, 0x1e, 0x14, 0x90, 0x61, 0x49, 0x39, 0x8b, - 0x25, 0x96, 0xf0, 0xad, 0x1c, 0x60, 0x09, 0xf6, 0x3e, 0x7a, 0xaa, 0x43, 0x12, 0x39, 0x4b, 0x72, - 0x2c, 0x72, 0xc5, 0x69, 0x44, 0x8f, 0xf5, 0xf8, 0x7c, 0x16, 0x62, 0x91, 0xdb, 0x9f, 0x50, 0x83, - 0xc1, 0x34, 0x11, 0xb5, 0xb5, 0x65, 0xed, 0x99, 0x07, 0x4f, 0x3a, 0x6f, 0xb7, 0x34, 0xb9, 0xc5, - 0x9a, 0x88, 0x68, 0x87, 0xc1, 0x54, 0x61, 0xdd, 0x21, 0x7a, 0xa1, 0x1a, 0xc5, 0x50, 0x40, 0x2a, - 0x69, 0x05, 0x71, 0x81, 0x45, 0x4e, 0x59, 0x66, 0x7f, 0x45, 0x3b, 0x50, 0x57, 0x67, 0x29, 0xe8, - 0x5d, 0x0f, 0xb7, 0x10, 0x6e, 0x79, 0x4f, 0xb4, 0x2f, 0xba, 0x4e, 0x70, 0xaf, 0x2c, 0xd4, 0x54, - 0xa0, 0x3e, 0x9f, 0xc2, 0xb8, 0x47, 0x85, 0xd4, 0x1b, 0x53, 0x84, 0x44, 0x6d, 0x83, 0x41, 0x72, - 0x7d, 0xd4, 0x70, 0x0b, 0x68, 0x53, 0xc0, 0x6a, 0x18, 0xaf, 0x22, 0x6e, 0x5e, 0x3d, 0x34, 0xa2, - 0x86, 0x4e, 0x3f, 0x2d, 0xed, 0x0c, 0x35, 0x89, 0x4c, 0x93, 0x01, 0x14, 0xab, 0xc3, 0x25, 0x13, - 0x95, 0xa0, 0xee, 0xb7, 0xdb, 0xe9, 0xde, 0x05, 0xdd, 0xf6, 0xc1, 0x42, 0x23, 0x7a, 0x46, 0x64, - 0xda, 0x83, 0x62, 0x6d, 0xd8, 0xce, 0xd1, 0xcb, 0xbb, 0x5a, 0xd9, 0x21, 0xb2, 0xca, 0x91, 0xda, - 0xf5, 0x51, 0xf0, 0xe1, 0xea, 0xf7, 0xeb, 0x6e, 0x46, 0x65, 0x3e, 0x21, 0x5e, 0xca, 0x7f, 0xf8, - 0xba, 0x44, 0x81, 0x89, 0x78, 0x47, 0xf9, 0xbf, 0xbf, 0xbe, 0x9c, 0x97, 0x20, 0xbc, 0xe0, 0x73, - 0xff, 0xb8, 0x7b, 0xd8, 0x9f, 0x90, 0x2f, 0x30, 0x8f, 0xac, 0x72, 0x14, 0x3c, 0x40, 0x16, 0x54, - 0xc1, 0xd9, 0xcf, 0x85, 0x63, 0x5e, 0x2e, 0x1c, 0xf3, 0xcf, 0xc2, 0x31, 0x2f, 0x96, 0x8e, 0x71, - 0xb9, 0x74, 0x8c, 0x5f, 0x4b, 0xc7, 0xf8, 0x7e, 0x8f, 0xe4, 0xd9, 0xfa, 0x53, 0x50, 0x18, 0xf2, - 0x50, 0xbd, 0x81, 0xe3, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x5a, 0xe3, 0x63, 0x7e, 0x03, - 0x00, 0x00, + // 500 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x93, 0xcb, 0x6e, 0xd3, 0x40, + 0x14, 0x86, 0x6d, 0x53, 0xa1, 0x64, 0xb8, 0x09, 0x2b, 0xa0, 0x28, 0x80, 0xa9, 0xbc, 0x28, 0x15, + 0x12, 0x76, 0x2f, 0x91, 0x60, 0x6d, 0xd2, 0xd4, 0x5c, 0x54, 0x45, 0x76, 0xd9, 0xb0, 0xb1, 0xc6, + 0xce, 0x89, 0x3d, 0xc4, 0x78, 0x46, 0x99, 0x89, 0x93, 0xbc, 0x45, 0xdf, 0x83, 0x17, 0x61, 0xd9, + 0x25, 0x62, 0x81, 0x50, 0xf2, 0x22, 0xc8, 0x63, 0x53, 0xa2, 0xe6, 0x22, 0x90, 0xd8, 0xd9, 0xa3, + 0xf3, 0x7f, 0xdf, 0x39, 0xc7, 0x1e, 0x64, 0x86, 0x38, 0x9c, 0xa5, 0x34, 0xb3, 0x43, 0x11, 0x71, + 0x81, 0x87, 0x24, 0x8b, 0xed, 0xfc, 0xd0, 0x86, 0x1c, 0x32, 0xc1, 0x2d, 0x36, 0xa2, 0x82, 0xea, + 0x0f, 0xaa, 0x1a, 0xeb, 0x4f, 0x8d, 0x95, 0x1f, 0xb6, 0x1a, 0x31, 0x8d, 0xa9, 0xac, 0xb0, 0x8b, + 0xa7, 0xb2, 0xb8, 0xb5, 0xb7, 0x1e, 0xb8, 0x14, 0x95, 0x75, 0xa6, 0x8f, 0x9a, 0x27, 0x85, 0xe4, + 0x0c, 0x26, 0x5d, 0x92, 0xe1, 0x94, 0x88, 0x59, 0x6f, 0x44, 0x73, 0xd2, 0x87, 0x91, 0xfe, 0x12, + 0x69, 0x03, 0xd6, 0x54, 0x77, 0xd5, 0xfd, 0x5b, 0x47, 0xcf, 0xac, 0xb5, 0x76, 0xeb, 0x7a, 0xc8, + 0xd3, 0x06, 0xcc, 0xbc, 0x50, 0xd1, 0x13, 0x49, 0x75, 0xce, 0x5f, 0x77, 0x20, 0x85, 0x18, 0x0b, + 0x42, 0x33, 0x5f, 0x60, 0x01, 0x1f, 0x58, 0x1f, 0x0b, 0xd0, 0xf7, 0xd0, 0xbd, 0x0a, 0x12, 0x88, + 0x69, 0x90, 0x60, 0x9e, 0x48, 0x4f, 0xdd, 0xbb, 0x53, 0x1d, 0x9f, 0x4f, 0x5d, 0xcc, 0x13, 0xfd, + 0x14, 0xd5, 0x33, 0x98, 0x04, 0xbc, 0x88, 0x36, 0xb5, 0x5d, 0x75, 0xff, 0xee, 0xd1, 0xf3, 0x0d, + 0x9d, 0xac, 0xb8, 0xc6, 0xdc, 0xab, 0x65, 0x30, 0x91, 0x5a, 0x73, 0x80, 0x1e, 0xca, 0x8e, 0x7c, + 0x48, 0x21, 0x12, 0x24, 0x07, 0x3f, 0xc5, 0x3c, 0x21, 0x59, 0xac, 0xbf, 0x47, 0x35, 0x28, 0x5a, + 0xcf, 0x22, 0xa8, 0x66, 0x3d, 0xd8, 0x60, 0x58, 0xc9, 0x9e, 0x54, 0x39, 0xef, 0x8a, 0x60, 0x7e, + 0xd9, 0x41, 0x0d, 0x29, 0xea, 0xd1, 0x09, 0x8c, 0x3a, 0x84, 0x8b, 0x6a, 0x62, 0x82, 0x10, 0x2f, + 0x62, 0xd0, 0x0f, 0xae, 0x96, 0xea, 0x6e, 0x10, 0xad, 0x03, 0x94, 0x87, 0x7e, 0x89, 0xb8, 0xbe, + 0x75, 0x57, 0xf1, 0xea, 0x15, 0xbd, 0xcb, 0xf4, 0x01, 0xaa, 0x7f, 0xc2, 0x24, 0x2d, 0x4d, 0x9a, + 0x34, 0x9d, 0xfe, 0xb3, 0xe9, 0xad, 0x24, 0xac, 0x11, 0xd5, 0x4a, 0x76, 0x97, 0xe9, 0x31, 0x6a, + 0x84, 0x22, 0x0a, 0xfa, 0x90, 0x96, 0x1f, 0x28, 0x18, 0xcb, 0x7c, 0xf3, 0x86, 0x54, 0xb6, 0xb7, + 0x29, 0x37, 0xfd, 0x18, 0xae, 0xe2, 0xdd, 0x0f, 0x45, 0xd4, 0x81, 0x74, 0xe9, 0xb0, 0x95, 0xa0, + 0xc7, 0xdb, 0xa6, 0xd7, 0x5d, 0xa4, 0xb1, 0xa1, 0xdc, 0xe9, 0x6d, 0xe7, 0xd5, 0xf7, 0x1f, 0x4f, + 0xdb, 0x31, 0x11, 0xc9, 0x38, 0xb4, 0x22, 0xfa, 0xd9, 0xae, 0x9a, 0x48, 0x71, 0xc8, 0x5f, 0x10, + 0xfa, 0xfb, 0xd5, 0x16, 0x33, 0x06, 0xdc, 0x72, 0xde, 0xf4, 0x8e, 0xdb, 0x07, 0xbd, 0x71, 0xf8, + 0x0e, 0x66, 0x9e, 0xc6, 0x86, 0xad, 0x18, 0x3d, 0xda, 0x32, 0xfd, 0xff, 0x13, 0x39, 0x3b, 0x48, + 0x83, 0xdc, 0x39, 0xfb, 0x3a, 0x37, 0xd4, 0xcb, 0xb9, 0xa1, 0xfe, 0x9c, 0x1b, 0xea, 0xc5, 0xc2, + 0x50, 0x2e, 0x17, 0x86, 0xf2, 0x6d, 0x61, 0x28, 0x1f, 0xff, 0x82, 0x3c, 0x5d, 0xbe, 0xdb, 0x52, + 0x13, 0xde, 0x94, 0x97, 0xfa, 0xf8, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0x57, 0xc3, 0x08, 0x28, + 0x4f, 0x04, 0x00, 0x00, } func (m *EventNewFinalityProvider) Marshal() (dAtA []byte, err error) { @@ -514,6 +573,27 @@ func (m *EventPowerDistUpdate_SlashedFp) MarshalToSizedBuffer(dAtA []byte) (int, } return len(dAtA) - i, nil } +func (m *EventPowerDistUpdate_JailedFp) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventPowerDistUpdate_JailedFp) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.JailedFp != nil { + { + size, err := m.JailedFp.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} func (m *EventPowerDistUpdate_BtcDelStateUpdate) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) @@ -531,7 +611,7 @@ func (m *EventPowerDistUpdate_BtcDelStateUpdate) MarshalToSizedBuffer(dAtA []byt i = encodeVarintEvents(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x12 + dAtA[i] = 0x1a } return len(dAtA) - i, nil } @@ -570,6 +650,41 @@ func (m *EventPowerDistUpdate_EventSlashedFinalityProvider) MarshalToSizedBuffer return len(dAtA) - i, nil } +func (m *EventPowerDistUpdate_EventJailedFinalityProvider) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventPowerDistUpdate_EventJailedFinalityProvider) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventPowerDistUpdate_EventJailedFinalityProvider) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pk != nil { + { + size := m.Pk.Size() + i -= size + if _, err := m.Pk.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func encodeVarintEvents(dAtA []byte, offset int, v uint64) int { offset -= sovEvents(v) base := offset @@ -647,6 +762,18 @@ func (m *EventPowerDistUpdate_SlashedFp) Size() (n int) { } return n } +func (m *EventPowerDistUpdate_JailedFp) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.JailedFp != nil { + l = m.JailedFp.Size() + n += 1 + l + sovEvents(uint64(l)) + } + return n +} func (m *EventPowerDistUpdate_BtcDelStateUpdate) Size() (n int) { if m == nil { return 0 @@ -672,6 +799,19 @@ func (m *EventPowerDistUpdate_EventSlashedFinalityProvider) Size() (n int) { return n } +func (m *EventPowerDistUpdate_EventJailedFinalityProvider) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Pk != nil { + l = m.Pk.Size() + n += 1 + l + sovEvents(uint64(l)) + } + return n +} + func sovEvents(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -1016,6 +1156,41 @@ func (m *EventPowerDistUpdate) Unmarshal(dAtA []byte) error { m.Ev = &EventPowerDistUpdate_SlashedFp{v} iNdEx = postIndex case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JailedFp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &EventPowerDistUpdate_EventJailedFinalityProvider{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Ev = &EventPowerDistUpdate_JailedFp{v} + iNdEx = postIndex + case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field BtcDelStateUpdate", wireType) } @@ -1156,6 +1331,91 @@ func (m *EventPowerDistUpdate_EventSlashedFinalityProvider) Unmarshal(dAtA []byt } return nil } +func (m *EventPowerDistUpdate_EventJailedFinalityProvider) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventJailedFinalityProvider: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventJailedFinalityProvider: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pk", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_babylonlabs_io_babylon_types.BIP340PubKey + m.Pk = &v + if err := m.Pk.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvents(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvents + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipEvents(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/btcstaking/types/query.go b/x/btcstaking/types/query.go index 1caecf29e..9f10dd209 100644 --- a/x/btcstaking/types/query.go +++ b/x/btcstaking/types/query.go @@ -66,7 +66,7 @@ func NewFinalityProviderResponse(f *FinalityProvider, bbnBlockHeight, votingPowe Pop: f.Pop, SlashedBabylonHeight: f.SlashedBabylonHeight, SlashedBtcHeight: f.SlashedBtcHeight, - Sluggish: f.Sluggish, + Jailed: f.Jailed, Height: bbnBlockHeight, VotingPower: votingPower, } diff --git a/x/btcstaking/types/query.pb.go b/x/btcstaking/types/query.pb.go index dc710bb9f..91b814236 100644 --- a/x/btcstaking/types/query.pb.go +++ b/x/btcstaking/types/query.pb.go @@ -1504,8 +1504,8 @@ type FinalityProviderResponse struct { Height uint64 `protobuf:"varint,8,opt,name=height,proto3" json:"height,omitempty"` // voting_power is the voting power of this finality provider at the given height VotingPower uint64 `protobuf:"varint,9,opt,name=voting_power,json=votingPower,proto3" json:"voting_power,omitempty"` - // sluggish defines whether the finality provider is detected sluggish - Sluggish bool `protobuf:"varint,10,opt,name=sluggish,proto3" json:"sluggish,omitempty"` + // jailed defines whether the finality provider is jailed + Jailed bool `protobuf:"varint,10,opt,name=jailed,proto3" json:"jailed,omitempty"` } func (m *FinalityProviderResponse) Reset() { *m = FinalityProviderResponse{} } @@ -1590,9 +1590,9 @@ func (m *FinalityProviderResponse) GetVotingPower() uint64 { return 0 } -func (m *FinalityProviderResponse) GetSluggish() bool { +func (m *FinalityProviderResponse) GetJailed() bool { if m != nil { - return m.Sluggish + return m.Jailed } return false } @@ -1629,126 +1629,125 @@ func init() { func init() { proto.RegisterFile("babylon/btcstaking/v1/query.proto", fileDescriptor_74d49d26f7429697) } var fileDescriptor_74d49d26f7429697 = []byte{ - // 1889 bytes of a gzipped FileDescriptorProto + // 1887 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x59, 0x4b, 0x6c, 0xdb, 0xc8, - 0x19, 0x0e, 0x6d, 0x45, 0xb1, 0x7f, 0xd9, 0x8e, 0x33, 0xeb, 0x24, 0x8c, 0x1c, 0xdb, 0x09, 0x9b, + 0x19, 0x0e, 0x6d, 0x45, 0x89, 0x7f, 0xd9, 0x8e, 0x33, 0xeb, 0x24, 0x8c, 0x1c, 0xdb, 0x09, 0x9b, 0x4d, 0x9c, 0x87, 0xc5, 0x58, 0xf1, 0x6e, 0x1f, 0xdb, 0xdd, 0xc4, 0xb2, 0x77, 0x93, 0xec, 0xae, - 0x1b, 0x95, 0x4e, 0x5a, 0xa0, 0x2f, 0x81, 0xa2, 0x46, 0x14, 0x11, 0x99, 0xc3, 0x70, 0x46, 0xae, - 0x8c, 0xc0, 0x97, 0x1e, 0x7a, 0x2b, 0x50, 0xa0, 0xbd, 0xf6, 0xdc, 0x16, 0x3d, 0x36, 0xa7, 0x02, - 0xbd, 0x6f, 0x6f, 0x8b, 0xf4, 0xb0, 0x45, 0x0e, 0x41, 0x91, 0x14, 0x2d, 0x50, 0xa0, 0xd7, 0x9e, - 0x0b, 0xce, 0x0c, 0x45, 0x4a, 0x22, 0x65, 0xc9, 0x76, 0x6f, 0xd6, 0xcc, 0xff, 0x9e, 0xef, 0xff, - 0x86, 0xf3, 0x1b, 0x2e, 0x57, 0xcd, 0xea, 0x5e, 0x93, 0xb8, 0x7a, 0x95, 0x59, 0x94, 0x99, 0x4f, - 0x1d, 0xd7, 0xd6, 0x77, 0x57, 0xf5, 0x67, 0x2d, 0xec, 0xef, 0x15, 0x3c, 0x9f, 0x30, 0x82, 0xce, - 0x4a, 0x91, 0x42, 0x24, 0x52, 0xd8, 0x5d, 0xcd, 0xcf, 0xd9, 0xc4, 0x26, 0x5c, 0x42, 0x0f, 0xfe, - 0x12, 0xc2, 0xf9, 0x8b, 0x36, 0x21, 0x76, 0x13, 0xeb, 0xa6, 0xe7, 0xe8, 0xa6, 0xeb, 0x12, 0x66, - 0x32, 0x87, 0xb8, 0x54, 0xee, 0x5e, 0xb0, 0x08, 0xdd, 0x21, 0xb4, 0x22, 0xd4, 0xc4, 0x0f, 0xb9, - 0x75, 0x45, 0xfc, 0xd2, 0xa3, 0x20, 0xaa, 0x98, 0x99, 0xab, 0xe1, 0x6f, 0x29, 0x75, 0x43, 0x4a, - 0x55, 0x4d, 0x8a, 0x45, 0x90, 0x1d, 0x41, 0xcf, 0xb4, 0x1d, 0x97, 0x7b, 0x93, 0xb2, 0x5a, 0x72, - 0x6a, 0x9e, 0xe9, 0x9b, 0x3b, 0xa1, 0xd7, 0xab, 0xc9, 0x32, 0xb1, 0x4c, 0x85, 0xdc, 0x52, 0x8a, - 0x2d, 0xe2, 0x09, 0x01, 0x6d, 0x0e, 0xd0, 0x77, 0x83, 0x70, 0xca, 0xdc, 0xba, 0x81, 0x9f, 0xb5, - 0x30, 0x65, 0x9a, 0x01, 0xef, 0x74, 0xad, 0x52, 0x8f, 0xb8, 0x14, 0xa3, 0x0f, 0x20, 0x2b, 0xa2, - 0x50, 0x95, 0x4b, 0xca, 0x72, 0xae, 0xb8, 0x50, 0x48, 0x2c, 0x71, 0x41, 0xa8, 0x95, 0x32, 0x5f, - 0xbc, 0x5e, 0x3a, 0x61, 0x48, 0x15, 0xed, 0xeb, 0x30, 0x1f, 0xb3, 0x59, 0xda, 0xfb, 0x1e, 0xf6, - 0xa9, 0x43, 0x5c, 0xe9, 0x12, 0xa9, 0x70, 0x6a, 0x57, 0xac, 0x70, 0xe3, 0xd3, 0x46, 0xf8, 0x53, - 0xfb, 0x21, 0x5c, 0x4c, 0x56, 0x3c, 0x8e, 0xa8, 0x6c, 0x58, 0xe0, 0xc6, 0x3f, 0x71, 0x5c, 0xb3, - 0xe9, 0xb0, 0xbd, 0xb2, 0x4f, 0x76, 0x9d, 0x1a, 0xf6, 0xc3, 0x52, 0xa0, 0x4f, 0x00, 0xa2, 0x13, - 0x92, 0x1e, 0xae, 0x16, 0x24, 0x04, 0x82, 0xe3, 0x2c, 0x08, 0xcc, 0xc9, 0xe3, 0x2c, 0x94, 0x4d, - 0x1b, 0x4b, 0x5d, 0x23, 0xa6, 0xa9, 0xfd, 0x45, 0x81, 0xc5, 0x34, 0x4f, 0x32, 0x91, 0x9f, 0x00, - 0xaa, 0xcb, 0xcd, 0x00, 0x69, 0x62, 0x57, 0x55, 0x2e, 0x8d, 0x2f, 0xe7, 0x8a, 0x7a, 0x4a, 0x52, - 0xbd, 0xd6, 0x42, 0x63, 0xc6, 0x99, 0x7a, 0xaf, 0x1f, 0x74, 0xbf, 0x2b, 0x95, 0x31, 0x9e, 0xca, - 0xb5, 0x03, 0x53, 0x91, 0xf6, 0xe2, 0xb9, 0xac, 0xcb, 0x13, 0xe9, 0x77, 0x2e, 0x6a, 0x76, 0x19, - 0xa6, 0xeb, 0x5e, 0xa5, 0xca, 0xac, 0x8a, 0xf7, 0xb4, 0xd2, 0xc0, 0x6d, 0x5e, 0xb6, 0x49, 0x03, - 0xea, 0x5e, 0x89, 0x59, 0xe5, 0xa7, 0x0f, 0x70, 0x5b, 0xdb, 0x4f, 0xa9, 0x7b, 0xa7, 0x18, 0x3f, - 0x82, 0x33, 0x7d, 0xc5, 0x90, 0xe5, 0x1f, 0xb9, 0x16, 0xb3, 0xbd, 0xb5, 0xd0, 0x7e, 0xa7, 0x40, - 0x9e, 0xfb, 0x2f, 0x3d, 0xde, 0xd8, 0xc4, 0x4d, 0x6c, 0x8b, 0x76, 0x0f, 0x13, 0x28, 0x41, 0x96, - 0x32, 0x93, 0xb5, 0x04, 0xa4, 0x66, 0x8a, 0x37, 0x52, 0x3c, 0x76, 0x69, 0x6f, 0x73, 0x0d, 0x43, - 0x6a, 0xf6, 0x00, 0x67, 0xec, 0xd0, 0xc0, 0xf9, 0xb3, 0x22, 0x1b, 0xa7, 0x37, 0x54, 0x59, 0xa8, - 0x27, 0x70, 0x3a, 0xa8, 0x74, 0x2d, 0xda, 0x92, 0x90, 0xb9, 0x35, 0x4c, 0xd0, 0x9d, 0x1a, 0xcd, - 0x54, 0x99, 0x15, 0x33, 0x7f, 0x7c, 0x60, 0xa9, 0xc3, 0xf5, 0xc4, 0x93, 0x2e, 0x93, 0x9f, 0x62, - 0x7f, 0x9d, 0x3d, 0xc0, 0x8e, 0xdd, 0x60, 0xc3, 0x23, 0x07, 0x9d, 0x83, 0x6c, 0x83, 0xeb, 0xf0, - 0xa0, 0x32, 0x86, 0xfc, 0xa5, 0x3d, 0x82, 0x1b, 0xc3, 0xf8, 0x91, 0x55, 0xbb, 0x0c, 0x53, 0xbb, - 0x84, 0x39, 0xae, 0x5d, 0xf1, 0x82, 0x7d, 0xee, 0x27, 0x63, 0xe4, 0xc4, 0x1a, 0x57, 0xd1, 0xb6, - 0x60, 0x39, 0xd1, 0xe0, 0x46, 0xcb, 0xf7, 0xb1, 0xcb, 0xb8, 0xd0, 0x08, 0x88, 0x4f, 0xab, 0x43, - 0xb7, 0x39, 0x19, 0x5e, 0x94, 0xa4, 0x12, 0x4f, 0xb2, 0x2f, 0xec, 0xb1, 0xfe, 0xb0, 0x7f, 0xa1, - 0xc0, 0x4d, 0xee, 0x68, 0xdd, 0x62, 0xce, 0x2e, 0xee, 0xa3, 0x9b, 0xde, 0x92, 0xa7, 0xb9, 0x3a, - 0x2e, 0xfc, 0x7e, 0xa5, 0xc0, 0xad, 0xe1, 0xe2, 0x39, 0x46, 0x1a, 0xfc, 0xbe, 0xc3, 0x1a, 0x5b, - 0x98, 0x99, 0xff, 0x57, 0x1a, 0x5c, 0x90, 0x8d, 0xc9, 0x13, 0x33, 0x19, 0xae, 0x75, 0x15, 0x56, - 0x7b, 0x5f, 0xb2, 0x64, 0xdf, 0xf6, 0xe0, 0x33, 0xd6, 0x7e, 0xad, 0xc0, 0xb5, 0x44, 0xa4, 0x24, - 0x10, 0xd5, 0x10, 0xfd, 0x72, 0x5c, 0xe7, 0xf8, 0x2f, 0x25, 0xa5, 0x1f, 0x92, 0x48, 0xc9, 0x87, - 0x0b, 0x31, 0x52, 0x22, 0x7e, 0x02, 0x3d, 0xbd, 0x7f, 0x20, 0x3d, 0x91, 0x24, 0xd3, 0xc6, 0xf9, - 0x88, 0xa8, 0xba, 0x04, 0x8e, 0xef, 0x5c, 0x3f, 0x85, 0x0b, 0xfd, 0x84, 0x1b, 0x56, 0x7c, 0x05, - 0xde, 0x91, 0xc1, 0x56, 0x58, 0xbb, 0xd2, 0x30, 0x69, 0x23, 0x56, 0xf7, 0x59, 0xb9, 0xf5, 0xb8, - 0xfd, 0xc0, 0xa4, 0x8d, 0xa0, 0xeb, 0x9f, 0x25, 0xdd, 0x33, 0x9d, 0x32, 0x6d, 0xc3, 0x4c, 0x37, - 0x77, 0xcb, 0x1b, 0x6e, 0x34, 0xea, 0x9e, 0xee, 0xa2, 0x6e, 0xed, 0xab, 0x2c, 0x9c, 0x4d, 0x76, - 0xf7, 0x4d, 0xc8, 0x05, 0xc6, 0xb0, 0x5f, 0x31, 0x6b, 0x35, 0xc1, 0x79, 0x93, 0x25, 0xf5, 0xe5, - 0x8b, 0x95, 0x39, 0x59, 0xa5, 0xf5, 0x5a, 0xcd, 0xc7, 0x94, 0x6e, 0x33, 0xdf, 0x71, 0x6d, 0x03, - 0x84, 0x70, 0xb0, 0x88, 0x1e, 0x41, 0x56, 0xa0, 0x8c, 0x17, 0x76, 0xaa, 0xf4, 0x8d, 0x57, 0xaf, - 0x97, 0xd6, 0x6c, 0x87, 0x35, 0x5a, 0xd5, 0x82, 0x45, 0x76, 0x74, 0x19, 0x6f, 0xd3, 0xac, 0xd2, - 0x15, 0x87, 0x84, 0x3f, 0x75, 0xb6, 0xe7, 0x61, 0x5a, 0x28, 0x3d, 0x2c, 0xdf, 0x59, 0xbb, 0x5d, - 0x6e, 0x55, 0x3f, 0xc3, 0x7b, 0xc6, 0xc9, 0x6a, 0x80, 0x4c, 0xf4, 0x63, 0x98, 0x89, 0x90, 0xdb, - 0x74, 0x28, 0x53, 0xc7, 0x2f, 0x8d, 0x1f, 0xc9, 0x70, 0x4e, 0x82, 0xfe, 0x73, 0x87, 0x37, 0xc6, - 0x14, 0x65, 0xa6, 0xcf, 0x2a, 0xb2, 0xc5, 0x32, 0x82, 0x28, 0xf9, 0x9a, 0xe8, 0x43, 0xb4, 0x00, - 0x80, 0xdd, 0x5a, 0x28, 0x70, 0x92, 0x0b, 0x4c, 0x62, 0x57, 0xb6, 0x29, 0x9a, 0x87, 0x49, 0x46, - 0x98, 0xd9, 0xac, 0x50, 0x93, 0xa9, 0x59, 0xbe, 0x3b, 0xc1, 0x17, 0xb6, 0x4d, 0x86, 0xae, 0xc0, - 0x4c, 0x1c, 0x05, 0xb8, 0xad, 0x9e, 0xe2, 0x00, 0x98, 0x8a, 0x00, 0x80, 0xdb, 0xe8, 0x2a, 0x9c, - 0xa6, 0x4d, 0x93, 0x36, 0x62, 0x62, 0x13, 0x5c, 0x6c, 0x3a, 0x5c, 0x16, 0x72, 0xef, 0xc1, 0xf9, - 0xa8, 0x53, 0xf8, 0x56, 0x85, 0x3a, 0x36, 0x97, 0x9f, 0xe4, 0xf2, 0x73, 0x9d, 0xed, 0xed, 0x60, - 0x77, 0xdb, 0xb1, 0x03, 0xb5, 0x27, 0x30, 0x6d, 0x91, 0x5d, 0xec, 0x9a, 0x2e, 0x0b, 0xe4, 0xa9, - 0x0a, 0xbc, 0xb1, 0x6e, 0xa7, 0x80, 0x67, 0x43, 0xca, 0xae, 0xd7, 0x4c, 0x2f, 0xb0, 0xe4, 0xd8, - 0xae, 0xc9, 0x5a, 0x3e, 0xa6, 0xc6, 0x54, 0x68, 0x66, 0xdb, 0xb1, 0x29, 0xba, 0x05, 0x28, 0xcc, - 0x8d, 0xb4, 0x98, 0xd7, 0x62, 0x15, 0xa7, 0xd6, 0x56, 0x73, 0xfc, 0xa3, 0x3c, 0x04, 0xf8, 0x23, - 0xbe, 0xf1, 0xb0, 0xc6, 0xaf, 0x63, 0x93, 0x13, 0xbb, 0x3a, 0x75, 0x49, 0x59, 0x9e, 0x30, 0xe4, - 0x2f, 0xb4, 0xc4, 0xb1, 0xc6, 0x5a, 0xb4, 0x52, 0xc3, 0xd4, 0x52, 0xa7, 0x05, 0x2f, 0x89, 0xa5, - 0x4d, 0x4c, 0x2d, 0xf4, 0x2e, 0xcc, 0xb4, 0xdc, 0x2a, 0x71, 0x6b, 0xbc, 0x3a, 0xce, 0x0e, 0x56, - 0x67, 0xb8, 0x8b, 0xe9, 0xce, 0xea, 0x63, 0x67, 0x07, 0x23, 0x0b, 0xce, 0xb6, 0xdc, 0xa8, 0x41, - 0x2a, 0xbe, 0x04, 0xb3, 0x7a, 0x9a, 0x77, 0x4a, 0x21, 0xbd, 0x53, 0x9e, 0xc4, 0xd4, 0x3a, 0xbd, - 0x32, 0xd7, 0x4a, 0x58, 0x0d, 0x62, 0x11, 0xef, 0x81, 0x4a, 0xf8, 0x06, 0x99, 0x15, 0xb1, 0x88, - 0x55, 0xf9, 0xe2, 0xd0, 0x5e, 0x8c, 0xc3, 0xf9, 0x14, 0xc3, 0x68, 0x19, 0x66, 0x63, 0xe9, 0xb4, - 0x63, 0xa4, 0x10, 0xa5, 0x29, 0x4e, 0xfb, 0x43, 0x98, 0x8f, 0x4e, 0x3b, 0xd2, 0x09, 0x4f, 0x7c, - 0x8c, 0x2b, 0xa9, 0x1d, 0x91, 0x27, 0xa1, 0x84, 0x3c, 0x75, 0x0b, 0xe6, 0x3b, 0xa7, 0xde, 0xad, - 0xdd, 0xe9, 0xa2, 0x5c, 0xf1, 0x4a, 0x4a, 0x59, 0x3a, 0x87, 0xfe, 0xd0, 0xad, 0x13, 0x43, 0x0d, - 0x0d, 0xc5, 0x7d, 0xf0, 0xf6, 0x49, 0x40, 0x6e, 0x26, 0x09, 0xb9, 0x1f, 0x40, 0xbe, 0x07, 0xb9, - 0xf1, 0x54, 0x4e, 0x72, 0x95, 0xf3, 0xdd, 0xe0, 0x8d, 0x32, 0xa9, 0xc3, 0xb9, 0x08, 0xbf, 0x31, - 0x5d, 0xaa, 0x66, 0x0f, 0x09, 0xe4, 0xb9, 0x0e, 0x90, 0x23, 0x4f, 0x54, 0xb3, 0x60, 0xe9, 0x80, - 0x4b, 0x05, 0xdd, 0x83, 0x4c, 0x0d, 0x37, 0x0f, 0xf7, 0xe5, 0xcc, 0x35, 0xb5, 0xdf, 0x67, 0x40, - 0x4d, 0x7d, 0xcc, 0x7c, 0x0c, 0xb9, 0xa0, 0x0b, 0x7c, 0xc7, 0x8b, 0x91, 0xfc, 0xd7, 0xc2, 0xbb, - 0x29, 0xf2, 0x20, 0x2e, 0xa6, 0xcd, 0x48, 0xd4, 0x88, 0xeb, 0xa1, 0x2d, 0x00, 0x8b, 0xec, 0xec, - 0x38, 0x94, 0x86, 0x37, 0xdc, 0x64, 0x69, 0xe5, 0xd5, 0xeb, 0xa5, 0x79, 0x61, 0x88, 0xd6, 0x9e, - 0x16, 0x1c, 0xa2, 0xef, 0x98, 0xac, 0x51, 0xf8, 0x1c, 0xdb, 0xa6, 0xb5, 0xb7, 0x89, 0xad, 0x97, - 0x2f, 0x56, 0x40, 0xfa, 0xd9, 0xc4, 0x96, 0x11, 0x33, 0x80, 0x6e, 0x41, 0x86, 0xdf, 0x03, 0xe3, - 0x07, 0xdc, 0x03, 0x5c, 0x2a, 0x76, 0x03, 0x64, 0x8e, 0xe7, 0x06, 0xf8, 0x10, 0xc6, 0x3d, 0xe2, - 0x71, 0x90, 0xe4, 0x8a, 0x37, 0xd3, 0x1e, 0xed, 0x3e, 0x21, 0xf5, 0x47, 0xf5, 0x32, 0xa1, 0x14, - 0xf3, 0xa8, 0x4b, 0x8f, 0x37, 0x8c, 0x40, 0x0f, 0xad, 0xc1, 0x39, 0x0e, 0x1a, 0x5c, 0xab, 0x48, - 0xd5, 0x90, 0xca, 0x05, 0x59, 0xcf, 0xc9, 0xdd, 0x92, 0xd8, 0x94, 0xac, 0x1e, 0x90, 0x5b, 0xa8, - 0xc5, 0xac, 0x50, 0xe3, 0x14, 0xd7, 0x98, 0x0d, 0x35, 0x98, 0x25, 0xa5, 0xa3, 0x4f, 0xb4, 0x89, - 0x81, 0x9f, 0xe1, 0x93, 0x7d, 0x9f, 0xe1, 0x28, 0x0f, 0x13, 0xb4, 0xd9, 0xb2, 0x6d, 0x87, 0x36, - 0x54, 0xe0, 0xcc, 0xd8, 0xf9, 0x5d, 0xfc, 0xcd, 0x19, 0x38, 0xc9, 0xbf, 0x0a, 0xd0, 0xcf, 0x15, - 0xc8, 0x8a, 0xb9, 0x04, 0xba, 0x9e, 0x52, 0x81, 0xfe, 0xf1, 0x4c, 0xfe, 0xc6, 0x30, 0xa2, 0x02, - 0x7a, 0xda, 0xbb, 0x3f, 0xfb, 0xeb, 0x3f, 0x7e, 0x35, 0xb6, 0x84, 0x16, 0xf4, 0x41, 0x63, 0x25, - 0xf4, 0x07, 0x05, 0x4e, 0xf7, 0x0c, 0x58, 0x50, 0xf1, 0x60, 0x37, 0xbd, 0x63, 0x9c, 0xfc, 0x9d, - 0x91, 0x74, 0x64, 0x8c, 0x3a, 0x8f, 0xf1, 0x3a, 0xba, 0x36, 0x30, 0x46, 0xfd, 0xb9, 0x24, 0xe7, - 0x7d, 0xf4, 0x47, 0x05, 0xce, 0xf4, 0x3d, 0x24, 0xd0, 0xda, 0x20, 0xdf, 0x69, 0x03, 0x9e, 0xfc, - 0x7b, 0x23, 0x6a, 0xc9, 0x98, 0x57, 0x79, 0xcc, 0x37, 0xd1, 0xf5, 0x94, 0x98, 0xfb, 0x9f, 0x30, - 0xe8, 0xa5, 0x02, 0xb3, 0xbd, 0x06, 0xd1, 0x9d, 0x51, 0xdc, 0x87, 0x31, 0xaf, 0x8d, 0xa6, 0x24, - 0x43, 0xde, 0xe6, 0x21, 0x6f, 0xa1, 0xcf, 0x86, 0x0e, 0x59, 0x7f, 0xde, 0xf5, 0xba, 0xd8, 0xef, - 0x17, 0x41, 0xbf, 0x55, 0x60, 0xa6, 0x7b, 0x32, 0x81, 0x56, 0x07, 0x45, 0x97, 0x38, 0x70, 0xc9, - 0x17, 0x47, 0x51, 0x91, 0xe9, 0x14, 0x78, 0x3a, 0xcb, 0xe8, 0xaa, 0x9e, 0x3a, 0x0c, 0x8d, 0x3f, - 0x3b, 0xd0, 0x3f, 0x15, 0x58, 0x3a, 0xe0, 0x0d, 0x8a, 0x4a, 0x83, 0xe2, 0x18, 0xee, 0x41, 0x9d, - 0xdf, 0x38, 0x92, 0x0d, 0x99, 0xdc, 0xb7, 0x78, 0x72, 0x6b, 0xa8, 0x38, 0xc2, 0x59, 0x09, 0x72, - 0xda, 0x47, 0xff, 0x55, 0x60, 0x61, 0xe0, 0x14, 0x04, 0xdd, 0x1b, 0x05, 0x3f, 0x49, 0x83, 0x9a, - 0xfc, 0xfa, 0x11, 0x2c, 0xc8, 0x14, 0xcb, 0x3c, 0xc5, 0x4f, 0xd1, 0x83, 0xc3, 0xc3, 0x91, 0xb3, - 0x6f, 0x94, 0xf8, 0xbf, 0x15, 0xb8, 0x38, 0x68, 0xbc, 0x82, 0xee, 0x8e, 0x12, 0x75, 0xc2, 0x9c, - 0x27, 0x7f, 0xef, 0xf0, 0x06, 0x64, 0xd6, 0xf7, 0x79, 0xd6, 0xeb, 0xe8, 0xee, 0x11, 0xb3, 0xe6, - 0x8c, 0xdd, 0x33, 0x5a, 0x18, 0xcc, 0xd8, 0xc9, 0x63, 0x8a, 0xc1, 0x8c, 0x9d, 0x32, 0xbb, 0x38, - 0x90, 0xb1, 0xcd, 0x50, 0x4f, 0xde, 0xb0, 0xe8, 0x3f, 0x0a, 0xcc, 0x0f, 0x18, 0x1c, 0xa0, 0x8f, - 0x46, 0x29, 0x6c, 0x02, 0x81, 0xdc, 0x3d, 0xb4, 0xbe, 0xcc, 0x68, 0x8b, 0x67, 0x74, 0x1f, 0x7d, - 0x7c, 0xf8, 0x73, 0x89, 0x93, 0xcd, 0x9f, 0x14, 0x98, 0xee, 0xe2, 0x2d, 0x74, 0x7b, 0x68, 0x8a, - 0x0b, 0x73, 0x5a, 0x1d, 0x41, 0x43, 0x66, 0xb1, 0xc9, 0xb3, 0xf8, 0x08, 0x7d, 0x7b, 0x38, 0x4e, - 0xd4, 0x9f, 0x27, 0xcc, 0x32, 0xf6, 0x4b, 0xdf, 0xf9, 0xe2, 0xcd, 0xa2, 0xf2, 0xe5, 0x9b, 0x45, - 0xe5, 0xef, 0x6f, 0x16, 0x95, 0x5f, 0xbe, 0x5d, 0x3c, 0xf1, 0xe5, 0xdb, 0xc5, 0x13, 0x7f, 0x7b, - 0xbb, 0x78, 0xe2, 0x07, 0x43, 0x7c, 0xf0, 0xb5, 0xe3, 0x2e, 0xf9, 0xd7, 0x5f, 0x35, 0xcb, 0xff, - 0xd7, 0x74, 0xe7, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x53, 0x66, 0x0a, 0xb8, 0xb5, 0x1b, 0x00, - 0x00, + 0x1b, 0x95, 0x4e, 0x5a, 0xa0, 0x2f, 0x81, 0x22, 0x47, 0x14, 0x1b, 0x89, 0xa3, 0x70, 0x46, 0xae, + 0x8c, 0xc0, 0x97, 0x1e, 0x7a, 0x2b, 0x50, 0xa0, 0xbd, 0xf6, 0x58, 0xb4, 0x40, 0x8f, 0xcd, 0xa9, + 0x40, 0xef, 0xdb, 0xdb, 0x22, 0x3d, 0x6c, 0xb1, 0x87, 0xa0, 0x48, 0x8a, 0x16, 0x28, 0xd0, 0x6b, + 0xcf, 0x05, 0x67, 0x86, 0x22, 0x25, 0x91, 0xb2, 0xe4, 0x78, 0x6f, 0xd6, 0xcc, 0xff, 0x9e, 0xef, + 0xff, 0x86, 0xf3, 0x1b, 0x2e, 0x55, 0xcd, 0xea, 0x5e, 0x83, 0x78, 0x7a, 0x95, 0x59, 0x94, 0x99, + 0x4f, 0x5c, 0xcf, 0xd1, 0x77, 0xd7, 0xf4, 0xa7, 0x6d, 0xec, 0xef, 0x15, 0x5a, 0x3e, 0x61, 0x04, + 0x9d, 0x91, 0x22, 0x85, 0x48, 0xa4, 0xb0, 0xbb, 0x96, 0x9f, 0x77, 0x88, 0x43, 0xb8, 0x84, 0x1e, + 0xfc, 0x25, 0x84, 0xf3, 0x17, 0x1c, 0x42, 0x9c, 0x06, 0xd6, 0xcd, 0x96, 0xab, 0x9b, 0x9e, 0x47, + 0x98, 0xc9, 0x5c, 0xe2, 0x51, 0xb9, 0x7b, 0xde, 0x22, 0xb4, 0x49, 0x68, 0x45, 0xa8, 0x89, 0x1f, + 0x72, 0xeb, 0xb2, 0xf8, 0xa5, 0x47, 0x41, 0x54, 0x31, 0x33, 0xd7, 0xc2, 0xdf, 0x52, 0xea, 0xba, + 0x94, 0xaa, 0x9a, 0x14, 0x8b, 0x20, 0xbb, 0x82, 0x2d, 0xd3, 0x71, 0x3d, 0xee, 0x4d, 0xca, 0x6a, + 0xc9, 0xa9, 0xb5, 0x4c, 0xdf, 0x6c, 0x86, 0x5e, 0xaf, 0x24, 0xcb, 0xc4, 0x32, 0x15, 0x72, 0xcb, + 0x29, 0xb6, 0x48, 0x4b, 0x08, 0x68, 0xf3, 0x80, 0xbe, 0x1b, 0x84, 0x53, 0xe6, 0xd6, 0x0d, 0xfc, + 0xb4, 0x8d, 0x29, 0xd3, 0x0c, 0x78, 0xab, 0x67, 0x95, 0xb6, 0x88, 0x47, 0x31, 0x7a, 0x0f, 0xb2, + 0x22, 0x0a, 0x55, 0xb9, 0xa8, 0xac, 0xe4, 0x8a, 0x8b, 0x85, 0xc4, 0x12, 0x17, 0x84, 0x5a, 0x29, + 0xf3, 0xd9, 0xcb, 0xe5, 0x63, 0x86, 0x54, 0xd1, 0xbe, 0x0e, 0x0b, 0x31, 0x9b, 0xa5, 0xbd, 0xef, + 0x61, 0x9f, 0xba, 0xc4, 0x93, 0x2e, 0x91, 0x0a, 0x27, 0x76, 0xc5, 0x0a, 0x37, 0x3e, 0x63, 0x84, + 0x3f, 0xb5, 0x1f, 0xc2, 0x85, 0x64, 0xc5, 0xa3, 0x88, 0xca, 0x81, 0x45, 0x6e, 0xfc, 0x23, 0xd7, + 0x33, 0x1b, 0x2e, 0xdb, 0x2b, 0xfb, 0x64, 0xd7, 0xb5, 0xb1, 0x1f, 0x96, 0x02, 0x7d, 0x04, 0x10, + 0x9d, 0x90, 0xf4, 0x70, 0xa5, 0x20, 0x21, 0x10, 0x1c, 0x67, 0x41, 0x60, 0x4e, 0x1e, 0x67, 0xa1, + 0x6c, 0x3a, 0x58, 0xea, 0x1a, 0x31, 0x4d, 0xed, 0xaf, 0x0a, 0x2c, 0xa5, 0x79, 0x92, 0x89, 0xfc, + 0x04, 0x50, 0x4d, 0x6e, 0x06, 0x48, 0x13, 0xbb, 0xaa, 0x72, 0x71, 0x72, 0x25, 0x57, 0xd4, 0x53, + 0x92, 0xea, 0xb7, 0x16, 0x1a, 0x33, 0x4e, 0xd7, 0xfa, 0xfd, 0xa0, 0x7b, 0x3d, 0xa9, 0x4c, 0xf0, + 0x54, 0xae, 0x1e, 0x98, 0x8a, 0xb4, 0x17, 0xcf, 0x65, 0x43, 0x9e, 0xc8, 0xa0, 0x73, 0x51, 0xb3, + 0x4b, 0x30, 0x53, 0x6b, 0x55, 0xaa, 0xcc, 0xaa, 0xb4, 0x9e, 0x54, 0xea, 0xb8, 0xc3, 0xcb, 0x36, + 0x65, 0x40, 0xad, 0x55, 0x62, 0x56, 0xf9, 0xc9, 0x7d, 0xdc, 0xd1, 0xf6, 0x53, 0xea, 0xde, 0x2d, + 0xc6, 0x8f, 0xe0, 0xf4, 0x40, 0x31, 0x64, 0xf9, 0xc7, 0xae, 0xc5, 0x5c, 0x7f, 0x2d, 0xb4, 0x3f, + 0x28, 0x90, 0xe7, 0xfe, 0x4b, 0x8f, 0x36, 0xb7, 0x70, 0x03, 0x3b, 0xa2, 0xdd, 0xc3, 0x04, 0x4a, + 0x90, 0xa5, 0xcc, 0x64, 0x6d, 0x01, 0xa9, 0xd9, 0xe2, 0xf5, 0x14, 0x8f, 0x3d, 0xda, 0x3b, 0x5c, + 0xc3, 0x90, 0x9a, 0x7d, 0xc0, 0x99, 0x38, 0x34, 0x70, 0xfe, 0xa2, 0xc8, 0xc6, 0xe9, 0x0f, 0x55, + 0x16, 0xea, 0x31, 0x9c, 0x0a, 0x2a, 0x6d, 0x47, 0x5b, 0x12, 0x32, 0x37, 0x47, 0x09, 0xba, 0x5b, + 0xa3, 0xd9, 0x2a, 0xb3, 0x62, 0xe6, 0x8f, 0x0e, 0x2c, 0x35, 0xb8, 0x96, 0x78, 0xd2, 0x65, 0xf2, + 0x33, 0xec, 0x6f, 0xb0, 0xfb, 0xd8, 0x75, 0xea, 0x6c, 0x74, 0xe4, 0xa0, 0xb3, 0x90, 0xad, 0x73, + 0x1d, 0x1e, 0x54, 0xc6, 0x90, 0xbf, 0xb4, 0x87, 0x70, 0x7d, 0x14, 0x3f, 0xb2, 0x6a, 0x97, 0x60, + 0x7a, 0x97, 0x30, 0xd7, 0x73, 0x2a, 0xad, 0x60, 0x9f, 0xfb, 0xc9, 0x18, 0x39, 0xb1, 0xc6, 0x55, + 0xb4, 0x6d, 0x58, 0x49, 0x34, 0xb8, 0xd9, 0xf6, 0x7d, 0xec, 0x31, 0x2e, 0x34, 0x06, 0xe2, 0xd3, + 0xea, 0xd0, 0x6b, 0x4e, 0x86, 0x17, 0x25, 0xa9, 0xc4, 0x93, 0x1c, 0x08, 0x7b, 0x62, 0x30, 0xec, + 0x5f, 0x2a, 0x70, 0x83, 0x3b, 0xda, 0xb0, 0x98, 0xbb, 0x8b, 0x07, 0xe8, 0xa6, 0xbf, 0xe4, 0x69, + 0xae, 0x8e, 0x0a, 0xbf, 0x5f, 0x28, 0x70, 0x73, 0xb4, 0x78, 0x8e, 0x90, 0x06, 0xbf, 0xef, 0xb2, + 0xfa, 0x36, 0x66, 0xe6, 0x57, 0x4a, 0x83, 0x8b, 0xb2, 0x31, 0x79, 0x62, 0x26, 0xc3, 0x76, 0x4f, + 0x61, 0xb5, 0x77, 0x25, 0x4b, 0x0e, 0x6c, 0x0f, 0x3f, 0x63, 0xed, 0x37, 0x0a, 0x5c, 0x4d, 0x44, + 0x4a, 0x02, 0x51, 0x8d, 0xd0, 0x2f, 0x47, 0x75, 0x8e, 0xff, 0x56, 0x52, 0xfa, 0x21, 0x89, 0x94, + 0x7c, 0x38, 0x1f, 0x23, 0x25, 0xe2, 0x27, 0xd0, 0xd3, 0xbb, 0x07, 0xd2, 0x13, 0x49, 0x32, 0x6d, + 0x9c, 0x8b, 0x88, 0xaa, 0x47, 0xe0, 0xe8, 0xce, 0xf5, 0x63, 0x38, 0x3f, 0x48, 0xb8, 0x61, 0xc5, + 0x57, 0xe1, 0x2d, 0x19, 0x6c, 0x85, 0x75, 0x2a, 0x75, 0x93, 0xd6, 0x63, 0x75, 0x9f, 0x93, 0x5b, + 0x8f, 0x3a, 0xf7, 0x4d, 0x5a, 0x0f, 0xba, 0xfe, 0x69, 0xd2, 0x3d, 0xd3, 0x2d, 0xd3, 0x0e, 0xcc, + 0xf6, 0x72, 0xb7, 0xbc, 0xe1, 0xc6, 0xa3, 0xee, 0x99, 0x1e, 0xea, 0xd6, 0xbe, 0xc8, 0xc2, 0x99, + 0x64, 0x77, 0xdf, 0x84, 0x5c, 0x60, 0x0c, 0xfb, 0x15, 0xd3, 0xb6, 0x05, 0xe7, 0x4d, 0x95, 0xd4, + 0x17, 0xcf, 0x57, 0xe7, 0x65, 0x95, 0x36, 0x6c, 0xdb, 0xc7, 0x94, 0xee, 0x30, 0xdf, 0xf5, 0x1c, + 0x03, 0x84, 0x70, 0xb0, 0x88, 0x1e, 0x42, 0x56, 0xa0, 0x8c, 0x17, 0x76, 0xba, 0xf4, 0x8d, 0x2f, + 0x5f, 0x2e, 0xaf, 0x3b, 0x2e, 0xab, 0xb7, 0xab, 0x05, 0x8b, 0x34, 0x75, 0x19, 0x6f, 0xc3, 0xac, + 0xd2, 0x55, 0x97, 0x84, 0x3f, 0x75, 0xb6, 0xd7, 0xc2, 0xb4, 0x50, 0x7a, 0x50, 0xbe, 0xbd, 0x7e, + 0xab, 0xdc, 0xae, 0x7e, 0x82, 0xf7, 0x8c, 0xe3, 0xd5, 0x00, 0x99, 0xe8, 0xc7, 0x30, 0x1b, 0x21, + 0xb7, 0xe1, 0x52, 0xa6, 0x4e, 0x5e, 0x9c, 0x7c, 0x23, 0xc3, 0x39, 0x09, 0xfa, 0x4f, 0x5d, 0xde, + 0x18, 0xd3, 0x94, 0x99, 0x3e, 0xab, 0xc8, 0x16, 0xcb, 0x08, 0xa2, 0xe4, 0x6b, 0xa2, 0x0f, 0xd1, + 0x22, 0x00, 0xf6, 0xec, 0x50, 0xe0, 0x38, 0x17, 0x98, 0xc2, 0x9e, 0x6c, 0x53, 0xb4, 0x00, 0x53, + 0x8c, 0x30, 0xb3, 0x51, 0xa1, 0x26, 0x53, 0xb3, 0x7c, 0xf7, 0x24, 0x5f, 0xd8, 0x31, 0x19, 0xba, + 0x0c, 0xb3, 0x71, 0x14, 0xe0, 0x8e, 0x7a, 0x82, 0x03, 0x60, 0x3a, 0x02, 0x00, 0xee, 0xa0, 0x2b, + 0x70, 0x8a, 0x36, 0x4c, 0x5a, 0x8f, 0x89, 0x9d, 0xe4, 0x62, 0x33, 0xe1, 0xb2, 0x90, 0x7b, 0x07, + 0xce, 0x45, 0x9d, 0xc2, 0xb7, 0x2a, 0xd4, 0x75, 0xb8, 0xfc, 0x14, 0x97, 0x9f, 0xef, 0x6e, 0xef, + 0x04, 0xbb, 0x3b, 0xae, 0x13, 0xa8, 0x3d, 0x86, 0x19, 0x8b, 0xec, 0x62, 0xcf, 0xf4, 0x58, 0x20, + 0x4f, 0x55, 0xe0, 0x8d, 0x75, 0x2b, 0x05, 0x3c, 0x9b, 0x52, 0x76, 0xc3, 0x36, 0x5b, 0x81, 0x25, + 0xd7, 0xf1, 0x4c, 0xd6, 0xf6, 0x31, 0x35, 0xa6, 0x43, 0x33, 0x3b, 0xae, 0x43, 0xd1, 0x4d, 0x40, + 0x61, 0x6e, 0xa4, 0xcd, 0x5a, 0x6d, 0x56, 0x71, 0xed, 0x8e, 0x9a, 0xe3, 0x1f, 0xe5, 0x21, 0xc0, + 0x1f, 0xf2, 0x8d, 0x07, 0x36, 0xbf, 0x8e, 0x4d, 0x4e, 0xec, 0xea, 0xf4, 0x45, 0x65, 0xe5, 0xa4, + 0x21, 0x7f, 0xa1, 0x65, 0x8e, 0x35, 0xd6, 0xa6, 0x15, 0x1b, 0x53, 0x4b, 0x9d, 0x11, 0xbc, 0x24, + 0x96, 0xb6, 0x30, 0xb5, 0xd0, 0xdb, 0x30, 0xdb, 0xf6, 0xaa, 0xc4, 0xb3, 0x79, 0x75, 0xdc, 0x26, + 0x56, 0x67, 0xb9, 0x8b, 0x99, 0xee, 0xea, 0x23, 0xb7, 0x89, 0x91, 0x05, 0x67, 0xda, 0x5e, 0xd4, + 0x20, 0x15, 0x5f, 0x82, 0x59, 0x3d, 0xc5, 0x3b, 0xa5, 0x90, 0xde, 0x29, 0x8f, 0x63, 0x6a, 0xdd, + 0x5e, 0x99, 0x6f, 0x27, 0xac, 0x06, 0xb1, 0x88, 0xf7, 0x40, 0x25, 0x7c, 0x83, 0xcc, 0x89, 0x58, + 0xc4, 0xaa, 0x7c, 0x71, 0x68, 0xcf, 0x27, 0xe1, 0x5c, 0x8a, 0x61, 0xb4, 0x02, 0x73, 0xb1, 0x74, + 0x3a, 0x31, 0x52, 0x88, 0xd2, 0x14, 0xa7, 0xfd, 0x3e, 0x2c, 0x44, 0xa7, 0x1d, 0xe9, 0x84, 0x27, + 0x3e, 0xc1, 0x95, 0xd4, 0xae, 0xc8, 0xe3, 0x50, 0x42, 0x9e, 0xba, 0x05, 0x0b, 0xdd, 0x53, 0xef, + 0xd5, 0xee, 0x76, 0x51, 0xae, 0x78, 0x39, 0xa5, 0x2c, 0xdd, 0x43, 0x7f, 0xe0, 0xd5, 0x88, 0xa1, + 0x86, 0x86, 0xe2, 0x3e, 0x78, 0xfb, 0x24, 0x20, 0x37, 0x93, 0x84, 0xdc, 0xf7, 0x20, 0xdf, 0x87, + 0xdc, 0x78, 0x2a, 0xc7, 0xb9, 0xca, 0xb9, 0x5e, 0xf0, 0x46, 0x99, 0xd4, 0xe0, 0x6c, 0x84, 0xdf, + 0x98, 0x2e, 0x55, 0xb3, 0x87, 0x04, 0xf2, 0x7c, 0x17, 0xc8, 0x91, 0x27, 0xaa, 0x59, 0xb0, 0x7c, + 0xc0, 0xa5, 0x82, 0xee, 0x42, 0xc6, 0xc6, 0x8d, 0xc3, 0x7d, 0x39, 0x73, 0x4d, 0xed, 0x77, 0x19, + 0x50, 0x53, 0x1f, 0x33, 0x1f, 0x42, 0x2e, 0xe8, 0x02, 0xdf, 0x6d, 0xc5, 0x48, 0xfe, 0x6b, 0xe1, + 0xdd, 0x14, 0x79, 0x10, 0x17, 0xd3, 0x56, 0x24, 0x6a, 0xc4, 0xf5, 0xd0, 0x36, 0x80, 0x45, 0x9a, + 0x4d, 0x97, 0xd2, 0xf0, 0x86, 0x9b, 0x2a, 0xad, 0x7e, 0xf9, 0x72, 0x79, 0x41, 0x18, 0xa2, 0xf6, + 0x93, 0x82, 0x4b, 0xf4, 0xa6, 0xc9, 0xea, 0x85, 0x4f, 0xb1, 0x63, 0x5a, 0x7b, 0x5b, 0xd8, 0x7a, + 0xf1, 0x7c, 0x15, 0xa4, 0x9f, 0x2d, 0x6c, 0x19, 0x31, 0x03, 0xe8, 0x26, 0x64, 0xf8, 0x3d, 0x30, + 0x79, 0xc0, 0x3d, 0xc0, 0xa5, 0x62, 0x37, 0x40, 0xe6, 0x68, 0x6e, 0x80, 0xf7, 0x61, 0xb2, 0x45, + 0x5a, 0x1c, 0x24, 0xb9, 0xe2, 0x8d, 0xb4, 0x47, 0xbb, 0x4f, 0x48, 0xed, 0x61, 0xad, 0x4c, 0x28, + 0xc5, 0x3c, 0xea, 0xd2, 0xa3, 0x4d, 0x23, 0xd0, 0x43, 0xeb, 0x70, 0x96, 0x83, 0x06, 0xdb, 0x15, + 0xa9, 0x1a, 0x52, 0xb9, 0x20, 0xeb, 0x79, 0xb9, 0x5b, 0x12, 0x9b, 0x92, 0xd5, 0x03, 0x72, 0x0b, + 0xb5, 0x98, 0x15, 0x6a, 0x9c, 0xe0, 0x1a, 0x73, 0xa1, 0x06, 0xb3, 0xa4, 0x74, 0xf4, 0x89, 0x76, + 0x72, 0xe8, 0x67, 0xf8, 0xd4, 0xc0, 0x67, 0x78, 0xa0, 0xfa, 0x53, 0xd3, 0x6d, 0x60, 0x5b, 0x05, + 0xc1, 0x8b, 0xe2, 0x57, 0xf1, 0xb7, 0xa7, 0xe1, 0x38, 0xff, 0x22, 0x40, 0xbf, 0x50, 0x20, 0x2b, + 0x66, 0x12, 0xe8, 0x5a, 0x4a, 0xf6, 0x83, 0xa3, 0x99, 0xfc, 0xf5, 0x51, 0x44, 0x05, 0xec, 0xb4, + 0xb7, 0x7f, 0xfe, 0xb7, 0x7f, 0xfe, 0x7a, 0x62, 0x19, 0x2d, 0xea, 0xc3, 0x46, 0x4a, 0xe8, 0x8f, + 0x0a, 0x9c, 0xea, 0x1b, 0xae, 0xa0, 0xe2, 0xc1, 0x6e, 0xfa, 0x47, 0x38, 0xf9, 0xdb, 0x63, 0xe9, + 0xc8, 0x18, 0x75, 0x1e, 0xe3, 0x35, 0x74, 0x75, 0x68, 0x8c, 0xfa, 0x33, 0x49, 0xcc, 0xfb, 0xe8, + 0x4f, 0x0a, 0x9c, 0x1e, 0x78, 0x44, 0xa0, 0xf5, 0x61, 0xbe, 0xd3, 0x86, 0x3b, 0xf9, 0x77, 0xc6, + 0xd4, 0x92, 0x31, 0xaf, 0xf1, 0x98, 0x6f, 0xa0, 0x6b, 0x29, 0x31, 0x0f, 0x3e, 0x5f, 0xd0, 0x0b, + 0x05, 0xe6, 0xfa, 0x0d, 0xa2, 0xdb, 0xe3, 0xb8, 0x0f, 0x63, 0x5e, 0x1f, 0x4f, 0x49, 0x86, 0xbc, + 0xc3, 0x43, 0xde, 0x46, 0x9f, 0x8c, 0x1c, 0xb2, 0xfe, 0xac, 0xe7, 0x65, 0xb1, 0x3f, 0x28, 0x82, + 0x7e, 0xaf, 0xc0, 0x6c, 0xef, 0x54, 0x02, 0xad, 0x0d, 0x8b, 0x2e, 0x71, 0xd8, 0x92, 0x2f, 0x8e, + 0xa3, 0x22, 0xd3, 0x29, 0xf0, 0x74, 0x56, 0xd0, 0x15, 0x3d, 0x75, 0x10, 0x1a, 0x7f, 0x72, 0xa0, + 0x7f, 0x29, 0xb0, 0x7c, 0xc0, 0xfb, 0x13, 0x95, 0x86, 0xc5, 0x31, 0xda, 0x63, 0x3a, 0xbf, 0xf9, + 0x46, 0x36, 0x64, 0x72, 0xdf, 0xe2, 0xc9, 0xad, 0xa3, 0xe2, 0x18, 0x67, 0x25, 0x88, 0x69, 0x1f, + 0xfd, 0x4f, 0x81, 0xc5, 0xa1, 0x13, 0x10, 0x74, 0x77, 0x1c, 0xfc, 0x24, 0x0d, 0x69, 0xf2, 0x1b, + 0x6f, 0x60, 0x41, 0xa6, 0x58, 0xe6, 0x29, 0x7e, 0x8c, 0xee, 0x1f, 0x1e, 0x8e, 0x9c, 0x79, 0xa3, + 0xc4, 0xff, 0xa3, 0xc0, 0x85, 0x61, 0xa3, 0x15, 0x74, 0x67, 0x9c, 0xa8, 0x13, 0x66, 0x3c, 0xf9, + 0xbb, 0x87, 0x37, 0x20, 0xb3, 0xbe, 0xc7, 0xb3, 0xde, 0x40, 0x77, 0xde, 0x30, 0x6b, 0xce, 0xd8, + 0x7d, 0x63, 0x85, 0xe1, 0x8c, 0x9d, 0x3c, 0xa2, 0x18, 0xce, 0xd8, 0x29, 0x73, 0x8b, 0x03, 0x19, + 0xdb, 0x0c, 0xf5, 0xe4, 0xed, 0x8a, 0xfe, 0xab, 0xc0, 0xc2, 0x90, 0xa1, 0x01, 0xfa, 0x60, 0x9c, + 0xc2, 0x26, 0x10, 0xc8, 0x9d, 0x43, 0xeb, 0xcb, 0x8c, 0xb6, 0x79, 0x46, 0xf7, 0xd0, 0x87, 0x87, + 0x3f, 0x97, 0x38, 0xd9, 0xfc, 0x59, 0x81, 0x99, 0x1e, 0xde, 0x42, 0xb7, 0x46, 0xa6, 0xb8, 0x30, + 0xa7, 0xb5, 0x31, 0x34, 0x64, 0x16, 0x5b, 0x3c, 0x8b, 0x0f, 0xd0, 0xb7, 0x47, 0xe3, 0x44, 0xfd, + 0x59, 0xc2, 0x1c, 0x63, 0xbf, 0xf4, 0x9d, 0xcf, 0x5e, 0x2d, 0x29, 0x9f, 0xbf, 0x5a, 0x52, 0xfe, + 0xf1, 0x6a, 0x49, 0xf9, 0xd5, 0xeb, 0xa5, 0x63, 0x9f, 0xbf, 0x5e, 0x3a, 0xf6, 0xf7, 0xd7, 0x4b, + 0xc7, 0x7e, 0x30, 0xc2, 0xc7, 0x5e, 0x27, 0xee, 0x92, 0x7f, 0xf9, 0x55, 0xb3, 0xfc, 0xff, 0x4c, + 0xb7, 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x5a, 0xfa, 0xfe, 0xb7, 0xb1, 0x1b, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -3280,9 +3279,9 @@ func (m *FinalityProviderResponse) MarshalToSizedBuffer(dAtA []byte) (int, error _ = i var l int _ = l - if m.Sluggish { + if m.Jailed { i-- - if m.Sluggish { + if m.Jailed { dAtA[i] = 1 } else { dAtA[i] = 0 @@ -3849,7 +3848,7 @@ func (m *FinalityProviderResponse) Size() (n int) { if m.VotingPower != 0 { n += 1 + sovQuery(uint64(m.VotingPower)) } - if m.Sluggish { + if m.Jailed { n += 2 } return n @@ -6931,7 +6930,7 @@ func (m *FinalityProviderResponse) Unmarshal(dAtA []byte) error { } case 10: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Sluggish", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Jailed", wireType) } var v int for shift := uint(0); ; shift += 7 { @@ -6948,7 +6947,7 @@ func (m *FinalityProviderResponse) Unmarshal(dAtA []byte) error { break } } - m.Sluggish = bool(v != 0) + m.Jailed = bool(v != 0) default: iNdEx = preIndex skippy, err := skipQuery(dAtA[iNdEx:]) diff --git a/x/finality/keeper/liveness.go b/x/finality/keeper/liveness.go index f46e52b37..13df748d4 100644 --- a/x/finality/keeper/liveness.go +++ b/x/finality/keeper/liveness.go @@ -38,7 +38,7 @@ func (k Keeper) HandleLiveness(ctx context.Context, height int64) { } // HandleFinalityProviderLiveness updates the voting history of the given finality provider and -// detect sluggish the finality provider if the number of missed block is reached to the threshold in a +// jail sluggish the finality provider if the number of missed block is reached to the threshold in a // sliding window func (k Keeper) HandleFinalityProviderLiveness(ctx context.Context, fpPk *types.BIP340PubKey, missed bool, height int64) error { params := k.GetParams(ctx) @@ -47,8 +47,8 @@ func (k Keeper) HandleFinalityProviderLiveness(ctx context.Context, fpPk *types. return err } - // don't update missed blocks when finality provider is already detected slashed - if fp.IsSlashed() { + // don't update missed blocks when finality provider is already slashed or jailed + if fp.IsSlashed() || fp.IsJailed() { return nil } @@ -87,45 +87,15 @@ func (k Keeper) HandleFinalityProviderLiveness(ctx context.Context, fpPk *types. "window_size", signedBlocksWindow, ) - // Inactivity detected - err = k.hooks.AfterSluggishFinalityProviderDetected(ctx, fpPk) - if err != nil { - return err - } - - if err := sdkCtx.EventManager().EmitTypedEvent( - finalitytypes.NewEventSluggishFinalityProviderDetected(fpPk), - ); err != nil { - panic(fmt.Errorf("failed to emit sluggish finality provider detected event for height %d: %w", height, err)) - } - - finalitytypes.IncrementSluggishFinalityProviderCounter() - } else if fp.IsSluggish() { - updated = true - - k.Logger(sdkCtx).Info( - "reverted sluggish finality provider", - "height", height, - "public_key", fpPk.MarshalHex(), - ) - - // change the sluggish flag of the finality provider to false - err = k.BTCStakingKeeper.RevertSluggishFinalityProvider(ctx, fpPk.MustMarshal()) - if err != nil { - return fmt.Errorf("failed to revert sluggish finality provider %s: %w", fpPk.MarshalHex(), err) + // sluggish finality provider detected + if err := k.jailSluggishFinalityProvider(ctx, fpPk); err != nil { + panic(fmt.Errorf("failed to jail sluggish finality provider %s: %w", fpPk.MarshalHex(), err)) } - - if err := sdkCtx.EventManager().EmitTypedEvent( - finalitytypes.NewEventSluggishFinalityProviderReverted(fpPk), - ); err != nil { - panic(fmt.Errorf("failed to emit sluggish finality provider reverted event for height %d: %w", height, err)) - } - - finalitytypes.DecrementSluggishFinalityProviderCounter() } // Set the updated signing info if updated { + signInfo.JailedUntil = sdkCtx.BlockHeader().Time.Add(params.JailDuration) return k.FinalityProviderSigningTracker.Set(ctx, fpPk.MustMarshal(), *signInfo) } @@ -200,3 +170,21 @@ func (k Keeper) updateSigningInfo( return modifiedSignInfo, &signInfo, nil } + +func (k Keeper) jailSluggishFinalityProvider(ctx context.Context, fpBtcPk *types.BIP340PubKey) error { + err := k.hooks.AfterSluggishFinalityProviderDetected(ctx, fpBtcPk) + if err != nil { + return err + } + + err = sdk.UnwrapSDKContext(ctx).EventManager().EmitTypedEvent( + finalitytypes.NewEventJailedFinalityProvider(fpBtcPk), + ) + if err != nil { + return fmt.Errorf("failed to emit sluggish finality provider detected event: %w", err) + } + + finalitytypes.IncrementSluggishFinalityProviderCounter() + + return nil +} diff --git a/x/finality/keeper/liveness_test.go b/x/finality/keeper/liveness_test.go index 74f25f2d6..a5c672725 100644 --- a/x/finality/keeper/liveness_test.go +++ b/x/finality/keeper/liveness_test.go @@ -34,7 +34,7 @@ func FuzzHandleLiveness(f *testing.F) { params := fKeeper.GetParams(ctx) fpPk, err := datagen.GenRandomBIP340PubKey(r) require.NoError(t, err) - bsKeeper.EXPECT().GetFinalityProvider(gomock.Any(), fpPk.MustMarshal()).Return(&bstypes.FinalityProvider{Sluggish: false}, nil).AnyTimes() + bsKeeper.EXPECT().GetFinalityProvider(gomock.Any(), fpPk.MustMarshal()).Return(&bstypes.FinalityProvider{Jailed: false}, nil).AnyTimes() signingInfo := types.NewFinalityProviderSigningInfo( fpPk, 1, diff --git a/x/finality/types/events.go b/x/finality/types/events.go index 6c6f400ca..b95d097e1 100644 --- a/x/finality/types/events.go +++ b/x/finality/types/events.go @@ -8,10 +8,6 @@ func NewEventSlashedFinalityProvider(evidence *Evidence) *EventSlashedFinalityPr } } -func NewEventSluggishFinalityProviderDetected(fpPk *types.BIP340PubKey) *EventSluggishFinalityProviderDetected { - return &EventSluggishFinalityProviderDetected{PublicKey: fpPk.MarshalHex()} -} - -func NewEventSluggishFinalityProviderReverted(fpPk *types.BIP340PubKey) *EventSluggishFinalityProviderReverted { - return &EventSluggishFinalityProviderReverted{PublicKey: fpPk.MarshalHex()} +func NewEventJailedFinalityProvider(fpPk *types.BIP340PubKey) *EventJailedFinalityProvider { + return &EventJailedFinalityProvider{PublicKey: fpPk.MarshalHex()} } diff --git a/x/finality/types/events.pb.go b/x/finality/types/events.pb.go index b6d9a35f6..945eb2c68 100644 --- a/x/finality/types/events.pb.go +++ b/x/finality/types/events.pb.go @@ -69,25 +69,25 @@ func (m *EventSlashedFinalityProvider) GetEvidence() *Evidence { return nil } -// EventSluggishFinalityProviderDetected is the event emitted when a finality provider is -// detected as sluggish -type EventSluggishFinalityProviderDetected struct { +// EventJailedFinalityProvider is the event emitted when a finality provider is +// jailed due to inactivity +type EventJailedFinalityProvider struct { // public_key is the BTC public key of the finality provider PublicKey string `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"` } -func (m *EventSluggishFinalityProviderDetected) Reset() { *m = EventSluggishFinalityProviderDetected{} } -func (m *EventSluggishFinalityProviderDetected) String() string { return proto.CompactTextString(m) } -func (*EventSluggishFinalityProviderDetected) ProtoMessage() {} -func (*EventSluggishFinalityProviderDetected) Descriptor() ([]byte, []int) { +func (m *EventJailedFinalityProvider) Reset() { *m = EventJailedFinalityProvider{} } +func (m *EventJailedFinalityProvider) String() string { return proto.CompactTextString(m) } +func (*EventJailedFinalityProvider) ProtoMessage() {} +func (*EventJailedFinalityProvider) Descriptor() ([]byte, []int) { return fileDescriptor_c34c03aae5e3e6bf, []int{1} } -func (m *EventSluggishFinalityProviderDetected) XXX_Unmarshal(b []byte) error { +func (m *EventJailedFinalityProvider) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *EventSluggishFinalityProviderDetected) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *EventJailedFinalityProvider) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_EventSluggishFinalityProviderDetected.Marshal(b, m, deterministic) + return xxx_messageInfo_EventJailedFinalityProvider.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -97,66 +97,19 @@ func (m *EventSluggishFinalityProviderDetected) XXX_Marshal(b []byte, determinis return b[:n], nil } } -func (m *EventSluggishFinalityProviderDetected) XXX_Merge(src proto.Message) { - xxx_messageInfo_EventSluggishFinalityProviderDetected.Merge(m, src) +func (m *EventJailedFinalityProvider) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventJailedFinalityProvider.Merge(m, src) } -func (m *EventSluggishFinalityProviderDetected) XXX_Size() int { +func (m *EventJailedFinalityProvider) XXX_Size() int { return m.Size() } -func (m *EventSluggishFinalityProviderDetected) XXX_DiscardUnknown() { - xxx_messageInfo_EventSluggishFinalityProviderDetected.DiscardUnknown(m) +func (m *EventJailedFinalityProvider) XXX_DiscardUnknown() { + xxx_messageInfo_EventJailedFinalityProvider.DiscardUnknown(m) } -var xxx_messageInfo_EventSluggishFinalityProviderDetected proto.InternalMessageInfo +var xxx_messageInfo_EventJailedFinalityProvider proto.InternalMessageInfo -func (m *EventSluggishFinalityProviderDetected) GetPublicKey() string { - if m != nil { - return m.PublicKey - } - return "" -} - -// EventSluggishFinalityProviderReverted is the event emitted when a sluggish finality -// provider is no longer considered sluggish -type EventSluggishFinalityProviderReverted struct { - // public_key is the BTC public key of the finality provider - PublicKey string `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"` -} - -func (m *EventSluggishFinalityProviderReverted) Reset() { *m = EventSluggishFinalityProviderReverted{} } -func (m *EventSluggishFinalityProviderReverted) String() string { return proto.CompactTextString(m) } -func (*EventSluggishFinalityProviderReverted) ProtoMessage() {} -func (*EventSluggishFinalityProviderReverted) Descriptor() ([]byte, []int) { - return fileDescriptor_c34c03aae5e3e6bf, []int{2} -} -func (m *EventSluggishFinalityProviderReverted) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *EventSluggishFinalityProviderReverted) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_EventSluggishFinalityProviderReverted.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *EventSluggishFinalityProviderReverted) XXX_Merge(src proto.Message) { - xxx_messageInfo_EventSluggishFinalityProviderReverted.Merge(m, src) -} -func (m *EventSluggishFinalityProviderReverted) XXX_Size() int { - return m.Size() -} -func (m *EventSluggishFinalityProviderReverted) XXX_DiscardUnknown() { - xxx_messageInfo_EventSluggishFinalityProviderReverted.DiscardUnknown(m) -} - -var xxx_messageInfo_EventSluggishFinalityProviderReverted proto.InternalMessageInfo - -func (m *EventSluggishFinalityProviderReverted) GetPublicKey() string { +func (m *EventJailedFinalityProvider) GetPublicKey() string { if m != nil { return m.PublicKey } @@ -165,14 +118,13 @@ func (m *EventSluggishFinalityProviderReverted) GetPublicKey() string { func init() { proto.RegisterType((*EventSlashedFinalityProvider)(nil), "babylon.finality.v1.EventSlashedFinalityProvider") - proto.RegisterType((*EventSluggishFinalityProviderDetected)(nil), "babylon.finality.v1.EventSluggishFinalityProviderDetected") - proto.RegisterType((*EventSluggishFinalityProviderReverted)(nil), "babylon.finality.v1.EventSluggishFinalityProviderReverted") + proto.RegisterType((*EventJailedFinalityProvider)(nil), "babylon.finality.v1.EventJailedFinalityProvider") } func init() { proto.RegisterFile("babylon/finality/v1/events.proto", fileDescriptor_c34c03aae5e3e6bf) } var fileDescriptor_c34c03aae5e3e6bf = []byte{ - // 252 bytes of a gzipped FileDescriptorProto + // 231 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x48, 0x4a, 0x4c, 0xaa, 0xcc, 0xc9, 0xcf, 0xd3, 0x4f, 0xcb, 0xcc, 0x4b, 0xcc, 0xc9, 0x2c, 0xa9, 0xd4, 0x2f, 0x33, 0xd4, 0x4f, 0x2d, 0x4b, 0xcd, 0x2b, 0x29, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x86, 0xaa, @@ -180,15 +132,14 @@ var fileDescriptor_c34c03aae5e3e6bf = []byte{ 0x92, 0x4b, 0xc6, 0x15, 0x64, 0x50, 0x70, 0x4e, 0x62, 0x71, 0x46, 0x6a, 0x8a, 0x1b, 0x54, 0x36, 0xa0, 0x28, 0xbf, 0x2c, 0x33, 0x25, 0xb5, 0x48, 0xc8, 0x92, 0x8b, 0x23, 0x15, 0xc4, 0xca, 0x4b, 0x4e, 0x95, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x36, 0x92, 0xd5, 0xc3, 0x62, 0x97, 0x9e, 0x2b, 0x54, - 0x51, 0x10, 0x5c, 0xb9, 0x92, 0x1b, 0x97, 0x2a, 0xd4, 0xe8, 0xd2, 0xf4, 0xf4, 0xcc, 0xe2, 0x0c, - 0x74, 0xb3, 0x5d, 0x52, 0x4b, 0x52, 0x93, 0x4b, 0x52, 0x53, 0x84, 0x64, 0xb9, 0xb8, 0x0a, 0x4a, - 0x93, 0x72, 0x32, 0x93, 0xe3, 0xb3, 0x53, 0x2b, 0xc1, 0xb6, 0x70, 0x06, 0x71, 0x42, 0x44, 0xbc, - 0x53, 0x2b, 0x09, 0x9a, 0x13, 0x94, 0x5a, 0x96, 0x5a, 0x44, 0xd8, 0x1c, 0x27, 0x9f, 0x13, 0x8f, - 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, 0x0b, - 0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96, 0x63, 0x88, 0x32, 0x4a, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, - 0x4b, 0xce, 0xcf, 0xd5, 0x87, 0x7a, 0x2e, 0x27, 0x31, 0xa9, 0x58, 0x37, 0x33, 0x1f, 0xc6, 0xd5, - 0xaf, 0x40, 0x04, 0x62, 0x49, 0x65, 0x41, 0x6a, 0x71, 0x12, 0x1b, 0x38, 0xfc, 0x8c, 0x01, 0x01, - 0x00, 0x00, 0xff, 0xff, 0x58, 0x3c, 0x4f, 0x58, 0x9c, 0x01, 0x00, 0x00, + 0x51, 0x10, 0x5c, 0xb9, 0x92, 0x0d, 0x97, 0x34, 0xd8, 0x68, 0xaf, 0xc4, 0xcc, 0x1c, 0x2c, 0x26, + 0xcb, 0x72, 0x71, 0x15, 0x94, 0x26, 0xe5, 0x64, 0x26, 0xc7, 0x67, 0xa7, 0x56, 0x82, 0xcd, 0xe6, + 0x0c, 0xe2, 0x84, 0x88, 0x78, 0xa7, 0x56, 0x3a, 0xf9, 0x9c, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, + 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x13, 0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70, 0xe3, + 0xb1, 0x1c, 0x43, 0x94, 0x51, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x3e, + 0xd4, 0x29, 0x39, 0x89, 0x49, 0xc5, 0xba, 0x99, 0xf9, 0x30, 0xae, 0x7e, 0x05, 0xc2, 0xcb, 0x25, + 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0x60, 0xdf, 0x1a, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xf0, + 0x48, 0xe5, 0x2e, 0x4a, 0x01, 0x00, 0x00, } func (m *EventSlashedFinalityProvider) Marshal() (dAtA []byte, err error) { @@ -226,37 +177,7 @@ func (m *EventSlashedFinalityProvider) MarshalToSizedBuffer(dAtA []byte) (int, e return len(dAtA) - i, nil } -func (m *EventSluggishFinalityProviderDetected) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *EventSluggishFinalityProviderDetected) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *EventSluggishFinalityProviderDetected) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.PublicKey) > 0 { - i -= len(m.PublicKey) - copy(dAtA[i:], m.PublicKey) - i = encodeVarintEvents(dAtA, i, uint64(len(m.PublicKey))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *EventSluggishFinalityProviderReverted) Marshal() (dAtA []byte, err error) { +func (m *EventJailedFinalityProvider) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -266,12 +187,12 @@ func (m *EventSluggishFinalityProviderReverted) Marshal() (dAtA []byte, err erro return dAtA[:n], nil } -func (m *EventSluggishFinalityProviderReverted) MarshalTo(dAtA []byte) (int, error) { +func (m *EventJailedFinalityProvider) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *EventSluggishFinalityProviderReverted) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *EventJailedFinalityProvider) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -310,20 +231,7 @@ func (m *EventSlashedFinalityProvider) Size() (n int) { return n } -func (m *EventSluggishFinalityProviderDetected) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.PublicKey) - if l > 0 { - n += 1 + l + sovEvents(uint64(l)) - } - return n -} - -func (m *EventSluggishFinalityProviderReverted) Size() (n int) { +func (m *EventJailedFinalityProvider) Size() (n int) { if m == nil { return 0 } @@ -428,89 +336,7 @@ func (m *EventSlashedFinalityProvider) Unmarshal(dAtA []byte) error { } return nil } -func (m *EventSluggishFinalityProviderDetected) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowEvents - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: EventSluggishFinalityProviderDetected: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: EventSluggishFinalityProviderDetected: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowEvents - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthEvents - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthEvents - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.PublicKey = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipEvents(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthEvents - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *EventSluggishFinalityProviderReverted) Unmarshal(dAtA []byte) error { +func (m *EventJailedFinalityProvider) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -533,10 +359,10 @@ func (m *EventSluggishFinalityProviderReverted) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: EventSluggishFinalityProviderReverted: wiretype end group for non-group") + return fmt.Errorf("proto: EventJailedFinalityProvider: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: EventSluggishFinalityProviderReverted: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EventJailedFinalityProvider: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: diff --git a/x/finality/types/finality.pb.go b/x/finality/types/finality.pb.go index 0b1804fbf..93c60cba2 100644 --- a/x/finality/types/finality.pb.go +++ b/x/finality/types/finality.pb.go @@ -6,17 +6,22 @@ package types import ( fmt "fmt" github_com_babylonlabs_io_babylon_types "github.com/babylonlabs-io/babylon/types" + _ "github.com/cosmos/cosmos-sdk/types/tx/amino" _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/cosmos/gogoproto/proto" + github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" + _ "google.golang.org/protobuf/types/known/timestamppb" io "io" math "math" math_bits "math/bits" + time "time" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf +var _ = time.Kitchen // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. @@ -252,6 +257,8 @@ type FinalityProviderSigningInfo struct { // missed_blocks_counter defines a counter to avoid unnecessary array reads. // Note that `Sum(MissedBlocksBitArray)` always equals `MissedBlocksCounter`. MissedBlocksCounter int64 `protobuf:"varint,3,opt,name=missed_blocks_counter,json=missedBlocksCounter,proto3" json:"missed_blocks_counter,omitempty"` + // Timestamp until which the validator is jailed due to liveness downtime. + JailedUntil time.Time `protobuf:"bytes,4,opt,name=jailed_until,json=jailedUntil,proto3,stdtime" json:"jailed_until"` } func (m *FinalityProviderSigningInfo) Reset() { *m = FinalityProviderSigningInfo{} } @@ -301,6 +308,13 @@ func (m *FinalityProviderSigningInfo) GetMissedBlocksCounter() int64 { return 0 } +func (m *FinalityProviderSigningInfo) GetJailedUntil() time.Time { + if m != nil { + return m.JailedUntil + } + return time.Time{} +} + func init() { proto.RegisterType((*IndexedBlock)(nil), "babylon.finality.v1.IndexedBlock") proto.RegisterType((*PubRandCommit)(nil), "babylon.finality.v1.PubRandCommit") @@ -313,43 +327,48 @@ func init() { } var fileDescriptor_ca5b87e52e3e6d02 = []byte{ - // 561 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x54, 0x4d, 0x6f, 0xd3, 0x40, - 0x10, 0x8d, 0x49, 0xc8, 0xc7, 0xc6, 0x15, 0xe0, 0x96, 0x2a, 0x50, 0xe4, 0x06, 0x9f, 0x72, 0x80, - 0x84, 0x7e, 0x08, 0x21, 0x6e, 0xb8, 0x2a, 0x6a, 0x04, 0x82, 0xc8, 0x29, 0x17, 0x2e, 0xab, 0xf5, - 0x7a, 0x6d, 0xaf, 0x12, 0xef, 0xae, 0xec, 0x75, 0xd4, 0xf0, 0x03, 0x38, 0xc3, 0xbf, 0x42, 0x9c, - 0x7a, 0x44, 0x3d, 0x54, 0x28, 0xf9, 0x23, 0xc8, 0x6b, 0xc7, 0x69, 0x4e, 0x20, 0x10, 0x37, 0xef, - 0x9b, 0xf1, 0xbc, 0x79, 0xb3, 0x6f, 0x16, 0x58, 0x2e, 0x72, 0xe7, 0x53, 0xce, 0x06, 0x3e, 0x65, - 0x68, 0x4a, 0xe5, 0x7c, 0x30, 0x3b, 0x28, 0xbf, 0xfb, 0x22, 0xe6, 0x92, 0x1b, 0xdb, 0x45, 0x4e, - 0xbf, 0xc4, 0x67, 0x07, 0x0f, 0x77, 0x02, 0x1e, 0x70, 0x15, 0x1f, 0x64, 0x5f, 0x79, 0xaa, 0x05, - 0x81, 0x3e, 0x64, 0x1e, 0xb9, 0x20, 0x9e, 0x3d, 0xe5, 0x78, 0x62, 0xec, 0x82, 0x7a, 0x48, 0x68, - 0x10, 0xca, 0x8e, 0xd6, 0xd5, 0x7a, 0x35, 0xa7, 0x38, 0x19, 0x0f, 0x40, 0x13, 0x09, 0x01, 0x43, - 0x94, 0x84, 0x9d, 0x5b, 0x5d, 0xad, 0xa7, 0x3b, 0x0d, 0x24, 0xc4, 0x19, 0x4a, 0x42, 0xe3, 0x11, - 0x68, 0xe5, 0x3c, 0x9f, 0x88, 0xd7, 0xa9, 0x76, 0xb5, 0x5e, 0xd3, 0x59, 0x03, 0xd6, 0x57, 0x0d, - 0x6c, 0x8d, 0x52, 0xd7, 0x41, 0xcc, 0x3b, 0xe1, 0x51, 0x44, 0xa5, 0xf1, 0x18, 0xe8, 0x89, 0x44, - 0xb1, 0x84, 0x1b, 0x44, 0x6d, 0x85, 0x9d, 0xe5, 0x6c, 0x5d, 0xa0, 0xb3, 0x34, 0x82, 0x22, 0x75, - 0x61, 0x8c, 0x98, 0xa7, 0x18, 0x6b, 0x0e, 0x60, 0x69, 0x54, 0x94, 0x32, 0x4c, 0x00, 0xb0, 0x2a, - 0x17, 0x11, 0x26, 0x15, 0xab, 0xee, 0xdc, 0x40, 0x8c, 0x3d, 0xd0, 0x22, 0x82, 0xe3, 0x10, 0xb2, - 0x34, 0xea, 0xd4, 0xd4, 0xef, 0x4d, 0x05, 0xbc, 0x4b, 0x23, 0xeb, 0x73, 0x0d, 0x34, 0x4f, 0x67, - 0xd4, 0x23, 0x0c, 0x13, 0xe3, 0x1c, 0xb4, 0x7c, 0x01, 0x5d, 0x89, 0xa1, 0x98, 0xa8, 0x5e, 0x74, - 0xfb, 0xc5, 0xd5, 0xf5, 0xfe, 0x71, 0x40, 0x65, 0x98, 0xba, 0x7d, 0xcc, 0xa3, 0x41, 0x31, 0xce, - 0x29, 0x72, 0x93, 0xa7, 0x94, 0xaf, 0x8e, 0x03, 0x39, 0x17, 0x24, 0xe9, 0xdb, 0xc3, 0xd1, 0xd1, - 0xf1, 0xb3, 0x51, 0xea, 0xbe, 0x21, 0x73, 0xa7, 0xe1, 0x0b, 0x5b, 0xe2, 0xd1, 0x24, 0x13, 0xe9, - 0x66, 0x03, 0x5d, 0x89, 0xcc, 0x15, 0xb4, 0x15, 0x56, 0x88, 0xfc, 0x00, 0x9a, 0xa5, 0x40, 0x25, - 0xc0, 0x7e, 0x79, 0x75, 0xbd, 0xff, 0xfc, 0x4f, 0x79, 0xc7, 0x38, 0x64, 0x3c, 0x8e, 0x8b, 0x81, - 0x38, 0x0d, 0x51, 0x4c, 0xe6, 0x09, 0x30, 0x30, 0x62, 0x9c, 0x51, 0x8c, 0xa6, 0xb0, 0xbc, 0xb3, - 0x9a, 0x9a, 0xd0, 0xdd, 0x32, 0xf2, 0xaa, 0xb8, 0x3c, 0x0b, 0x6c, 0xf9, 0x3c, 0x9e, 0xac, 0x13, - 0x6f, 0xab, 0xc4, 0x76, 0x06, 0xae, 0x72, 0x04, 0xd8, 0x5d, 0x57, 0x5c, 0x59, 0x0a, 0x26, 0x34, - 0xe8, 0xd4, 0xff, 0xba, 0xed, 0xd3, 0xf7, 0xe7, 0xe3, 0x31, 0x0d, 0x9c, 0x9d, 0xb2, 0xf2, 0xeb, - 0xa2, 0xf0, 0x98, 0x06, 0x86, 0x0f, 0xee, 0xa9, 0xae, 0x36, 0xc8, 0x1a, 0xff, 0x4c, 0x76, 0x27, - 0x2b, 0x7a, 0x83, 0xc7, 0xfa, 0xae, 0x81, 0xbd, 0xd5, 0x79, 0x14, 0xf3, 0xcc, 0x12, 0xf1, 0x98, - 0x06, 0x8c, 0xb2, 0x60, 0xc8, 0x7c, 0xfe, 0xff, 0xbc, 0xb1, 0xb1, 0x00, 0x99, 0x37, 0xaa, 0x9b, - 0x0b, 0x70, 0x08, 0xee, 0x47, 0x34, 0x49, 0x88, 0x07, 0x95, 0x63, 0x12, 0x88, 0x79, 0xca, 0x24, - 0x89, 0x95, 0x51, 0xaa, 0xce, 0x76, 0x1e, 0x54, 0x2b, 0x9b, 0x9c, 0xe4, 0x21, 0xfb, 0xed, 0xb7, - 0x85, 0xa9, 0x5d, 0x2e, 0x4c, 0xed, 0xe7, 0xc2, 0xd4, 0xbe, 0x2c, 0xcd, 0xca, 0xe5, 0xd2, 0xac, - 0xfc, 0x58, 0x9a, 0x95, 0x8f, 0x87, 0xbf, 0xef, 0xf7, 0x62, 0xfd, 0x9e, 0xa8, 0xd6, 0xdd, 0xba, - 0x7a, 0x1f, 0x8e, 0x7e, 0x05, 0x00, 0x00, 0xff, 0xff, 0x1b, 0xa1, 0x77, 0x79, 0x70, 0x04, 0x00, - 0x00, + // 646 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x54, 0xcf, 0x6e, 0xd3, 0x4e, + 0x10, 0x8e, 0xdb, 0xfc, 0x9a, 0x74, 0xe3, 0xea, 0x47, 0xdd, 0x52, 0x85, 0x16, 0x39, 0x21, 0xa7, + 0x0a, 0x81, 0x4d, 0xff, 0x08, 0x21, 0x6e, 0xb8, 0x2a, 0x6a, 0x45, 0x05, 0x91, 0xd3, 0x5e, 0xb8, + 0xac, 0xd6, 0xf6, 0xda, 0x5e, 0x62, 0xef, 0xae, 0xec, 0x75, 0xd5, 0xf0, 0x00, 0x9c, 0xcb, 0x8d, + 0x47, 0xe0, 0xc8, 0x63, 0xf4, 0xd8, 0x23, 0xea, 0xa1, 0xa0, 0xe6, 0xc0, 0x6b, 0x20, 0xaf, 0xed, + 0xa4, 0x39, 0x81, 0x40, 0x5c, 0x2c, 0xef, 0x37, 0xb3, 0xf3, 0xcd, 0x37, 0x33, 0x3b, 0xa0, 0xe7, + 0x20, 0x67, 0x14, 0x31, 0x6a, 0xfa, 0x84, 0xa2, 0x88, 0x88, 0x91, 0x79, 0xba, 0x35, 0xf9, 0x37, + 0x78, 0xc2, 0x04, 0xd3, 0x56, 0x4a, 0x1f, 0x63, 0x82, 0x9f, 0x6e, 0xad, 0xaf, 0x06, 0x2c, 0x60, + 0xd2, 0x6e, 0xe6, 0x7f, 0x85, 0xeb, 0xfa, 0x32, 0x8a, 0x09, 0x65, 0xa6, 0xfc, 0x96, 0x50, 0x27, + 0x60, 0x2c, 0x88, 0xb0, 0x29, 0x4f, 0x4e, 0xe6, 0x9b, 0x82, 0xc4, 0x38, 0x15, 0x28, 0xe6, 0x85, + 0x43, 0x0f, 0x02, 0xf5, 0x90, 0x7a, 0xf8, 0x0c, 0x7b, 0x56, 0xc4, 0xdc, 0xa1, 0xb6, 0x06, 0x16, + 0x42, 0x4c, 0x82, 0x50, 0xb4, 0x95, 0xae, 0xb2, 0x59, 0xb7, 0xcb, 0x93, 0x76, 0x0f, 0x34, 0x11, + 0xe7, 0x30, 0x44, 0x69, 0xd8, 0x9e, 0xeb, 0x2a, 0x9b, 0xaa, 0xdd, 0x40, 0x9c, 0x1f, 0xa0, 0x34, + 0xd4, 0xee, 0x83, 0xc5, 0x22, 0xb7, 0xf7, 0xd8, 0x6b, 0xcf, 0x77, 0x95, 0xcd, 0xa6, 0x3d, 0x05, + 0x7a, 0x1f, 0x15, 0xb0, 0xd4, 0xcf, 0x1c, 0x1b, 0x51, 0x6f, 0x8f, 0xc5, 0x31, 0x11, 0xda, 0x03, + 0xa0, 0xa6, 0x02, 0x25, 0x02, 0xce, 0x10, 0xb5, 0x24, 0x76, 0x50, 0xb0, 0x75, 0x81, 0x4a, 0xb3, + 0x18, 0xf2, 0xcc, 0x81, 0x09, 0xa2, 0x9e, 0x64, 0xac, 0xdb, 0x80, 0x66, 0x71, 0x19, 0x4a, 0xd3, + 0x01, 0x70, 0x65, 0xb8, 0x18, 0x53, 0x21, 0x59, 0x55, 0xfb, 0x16, 0xa2, 0x6d, 0x80, 0x45, 0xcc, + 0x99, 0x1b, 0x42, 0x9a, 0xc5, 0xed, 0xba, 0xbc, 0xde, 0x94, 0xc0, 0xeb, 0x2c, 0xee, 0x7d, 0xa8, + 0x83, 0xe6, 0xfe, 0x29, 0xf1, 0x30, 0x75, 0xb1, 0x76, 0x0c, 0x16, 0x7d, 0x0e, 0x1d, 0xe1, 0x42, + 0x3e, 0x94, 0xb9, 0xa8, 0xd6, 0xb3, 0xab, 0xeb, 0xce, 0x6e, 0x40, 0x44, 0x98, 0x39, 0x86, 0xcb, + 0x62, 0xb3, 0x6c, 0x41, 0x84, 0x9c, 0xf4, 0x31, 0x61, 0xd5, 0xd1, 0x14, 0x23, 0x8e, 0x53, 0xc3, + 0x3a, 0xec, 0xef, 0xec, 0x3e, 0xe9, 0x67, 0xce, 0x2b, 0x3c, 0xb2, 0x1b, 0x3e, 0xb7, 0x84, 0xdb, + 0x1f, 0xe6, 0x22, 0x9d, 0xbc, 0xa0, 0x95, 0xc8, 0x42, 0x41, 0x4b, 0x62, 0xa5, 0xc8, 0x13, 0xd0, + 0x9c, 0x08, 0x94, 0x02, 0xac, 0xe7, 0x57, 0xd7, 0x9d, 0xa7, 0xbf, 0xcb, 0x3b, 0x70, 0x43, 0xca, + 0x92, 0xa4, 0x2c, 0x88, 0xdd, 0xe0, 0x65, 0x65, 0x1e, 0x01, 0xcd, 0x45, 0x94, 0x51, 0xe2, 0xa2, + 0x08, 0x4e, 0x7a, 0x56, 0x97, 0x15, 0xba, 0x33, 0xb1, 0xbc, 0x28, 0x9b, 0xd7, 0x03, 0x4b, 0x3e, + 0x4b, 0x86, 0x53, 0xc7, 0xff, 0xa4, 0x63, 0x2b, 0x07, 0x2b, 0x1f, 0x0e, 0xd6, 0xa6, 0x11, 0xab, + 0x31, 0x84, 0x29, 0x09, 0xda, 0x0b, 0x7f, 0x9c, 0xf6, 0xfe, 0x9b, 0xe3, 0xc1, 0x80, 0x04, 0xf6, + 0xea, 0x24, 0xf2, 0xcb, 0x32, 0xf0, 0x80, 0x04, 0x9a, 0x0f, 0x96, 0x65, 0x56, 0x33, 0x64, 0x8d, + 0xbf, 0x26, 0xfb, 0x3f, 0x0f, 0x7a, 0x8b, 0xa7, 0xf7, 0x69, 0x0e, 0x6c, 0x54, 0xe7, 0x7e, 0xc2, + 0xf2, 0x91, 0x48, 0x06, 0x24, 0xa0, 0x84, 0x06, 0x87, 0xd4, 0x67, 0xff, 0x6e, 0x36, 0x66, 0x1e, + 0x40, 0x3e, 0x1b, 0xf3, 0xb3, 0x0f, 0x60, 0x1b, 0xdc, 0x8d, 0x49, 0x9a, 0x62, 0x0f, 0xca, 0x89, + 0x49, 0xa1, 0xcb, 0x32, 0x2a, 0x70, 0x22, 0x07, 0x65, 0xde, 0x5e, 0x29, 0x8c, 0xf2, 0xc9, 0xa6, + 0x7b, 0x85, 0x49, 0x3b, 0x02, 0xea, 0x3b, 0x44, 0x22, 0xec, 0xc1, 0x8c, 0x0a, 0x12, 0xc9, 0x96, + 0xb7, 0xb6, 0xd7, 0x8d, 0x62, 0x05, 0x18, 0xd5, 0x0a, 0x30, 0x8e, 0xab, 0x15, 0x60, 0x2d, 0x5d, + 0x5c, 0x77, 0x6a, 0xe7, 0xdf, 0x3a, 0xca, 0xe7, 0x1f, 0x5f, 0x1e, 0x2a, 0x76, 0xab, 0xb8, 0x7e, + 0x92, 0xdf, 0xb6, 0x8e, 0x2e, 0x6e, 0x74, 0xe5, 0xf2, 0x46, 0x57, 0xbe, 0xdf, 0xe8, 0xca, 0xf9, + 0x58, 0xaf, 0x5d, 0x8e, 0xf5, 0xda, 0xd7, 0xb1, 0x5e, 0x7b, 0xbb, 0xfd, 0x6b, 0xf5, 0x67, 0xd3, + 0x8d, 0x26, 0x0b, 0xe1, 0x2c, 0x48, 0xf6, 0x9d, 0x9f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa3, 0xae, + 0x27, 0x1f, 0xf2, 0x04, 0x00, 0x00, } func (m *IndexedBlock) Marshal() (dAtA []byte, err error) { @@ -552,6 +571,14 @@ func (m *FinalityProviderSigningInfo) MarshalToSizedBuffer(dAtA []byte) (int, er _ = i var l int _ = l + n1, err1 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.JailedUntil, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.JailedUntil):]) + if err1 != nil { + return 0, err1 + } + i -= n1 + i = encodeVarintFinality(dAtA, i, uint64(n1)) + i-- + dAtA[i] = 0x22 if m.MissedBlocksCounter != 0 { i = encodeVarintFinality(dAtA, i, uint64(m.MissedBlocksCounter)) i-- @@ -681,6 +708,8 @@ func (m *FinalityProviderSigningInfo) Size() (n int) { if m.MissedBlocksCounter != 0 { n += 1 + sovFinality(uint64(m.MissedBlocksCounter)) } + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.JailedUntil) + n += 1 + l + sovFinality(uint64(l)) return n } @@ -1333,6 +1362,39 @@ func (m *FinalityProviderSigningInfo) Unmarshal(dAtA []byte) error { break } } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JailedUntil", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFinality + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFinality + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthFinality + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.JailedUntil, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipFinality(dAtA[iNdEx:]) diff --git a/x/finality/types/params.pb.go b/x/finality/types/params.pb.go index cec13955b..93386cad6 100644 --- a/x/finality/types/params.pb.go +++ b/x/finality/types/params.pb.go @@ -10,15 +10,19 @@ import ( _ "github.com/cosmos/cosmos-sdk/types/tx/amino" _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/cosmos/gogoproto/proto" + github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" + _ "google.golang.org/protobuf/types/known/durationpb" io "io" math "math" math_bits "math/bits" + time "time" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf +var _ = time.Kitchen // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. @@ -39,6 +43,8 @@ type Params struct { // min_pub_rand is the minimum number of public randomness each // message should commit MinPubRand uint64 `protobuf:"varint,4,opt,name=min_pub_rand,json=minPubRand,proto3" json:"min_pub_rand,omitempty"` + // jail_duration is the minimum period of time that a finality provider remains jailed + JailDuration time.Duration `protobuf:"bytes,5,opt,name=jail_duration,json=jailDuration,proto3,stdduration" json:"jail_duration"` } func (m *Params) Reset() { *m = Params{} } @@ -94,6 +100,13 @@ func (m *Params) GetMinPubRand() uint64 { return 0 } +func (m *Params) GetJailDuration() time.Duration { + if m != nil { + return m.JailDuration + } + return 0 +} + func init() { proto.RegisterType((*Params)(nil), "babylon.finality.v1.Params") } @@ -101,30 +114,34 @@ func init() { func init() { proto.RegisterFile("babylon/finality/v1/params.proto", fileDescriptor_25539c9a61c72ee9) } var fileDescriptor_25539c9a61c72ee9 = []byte{ - // 361 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x44, 0x91, 0x31, 0x6b, 0xe3, 0x30, - 0x14, 0xc7, 0xad, 0x4b, 0xc8, 0x60, 0xb2, 0x9c, 0x2f, 0x07, 0xb9, 0x1c, 0x38, 0xe6, 0xa6, 0x70, - 0x10, 0xab, 0x69, 0xa1, 0x43, 0xc7, 0x90, 0x31, 0x43, 0x70, 0x0a, 0x85, 0x2e, 0x46, 0xb2, 0x55, - 0xe7, 0x11, 0x4b, 0x32, 0x96, 0x9d, 0xd4, 0xdf, 0xa2, 0x63, 0xc7, 0x8e, 0x1d, 0x3b, 0xf4, 0x43, - 0x64, 0x0c, 0x9d, 0x4a, 0x87, 0x50, 0x92, 0xa1, 0x1f, 0xa3, 0x25, 0x96, 0x4d, 0x17, 0xa1, 0xa7, - 0xdf, 0xff, 0xe9, 0xff, 0xd7, 0x93, 0xe9, 0x50, 0x42, 0x8b, 0x58, 0x0a, 0x7c, 0x03, 0x82, 0xc4, - 0x90, 0x15, 0x78, 0x35, 0xc2, 0x09, 0x49, 0x09, 0x57, 0x6e, 0x92, 0xca, 0x4c, 0x5a, 0xbf, 0x2a, - 0x85, 0x5b, 0x2b, 0xdc, 0xd5, 0xa8, 0xd7, 0x89, 0x64, 0x24, 0x4b, 0x8e, 0x8f, 0x3b, 0x2d, 0xed, - 0xfd, 0x24, 0x1c, 0x84, 0xc4, 0xe5, 0x5a, 0x1d, 0xfd, 0x09, 0xa4, 0xe2, 0x52, 0xf9, 0x5a, 0xab, - 0x0b, 0x8d, 0xfe, 0x7d, 0x22, 0xb3, 0x35, 0x2b, 0x9d, 0xac, 0x13, 0xb3, 0xa3, 0x20, 0x12, 0x2c, - 0xf4, 0x69, 0x2c, 0x83, 0xa5, 0xf2, 0xd7, 0x20, 0x42, 0xb9, 0xee, 0x22, 0x07, 0x0d, 0x1a, 0x9e, - 0xa5, 0xd9, 0xb8, 0x44, 0x57, 0x25, 0x39, 0x76, 0xd4, 0x79, 0x7c, 0x05, 0x91, 0x9f, 0x01, 0x67, - 0x32, 0xcf, 0xba, 0x3f, 0x74, 0x47, 0xcd, 0xe6, 0x10, 0x5d, 0x6a, 0x62, 0x81, 0xf9, 0x9b, 0x83, - 0xf0, 0x2b, 0x9f, 0x84, 0xa5, 0xb5, 0x49, 0xc3, 0x41, 0x83, 0xf6, 0xf8, 0x7c, 0xb3, 0xeb, 0x1b, - 0x6f, 0xbb, 0xfe, 0x5f, 0x9d, 0x51, 0x85, 0x4b, 0x17, 0x24, 0xe6, 0x24, 0x5b, 0xb8, 0x53, 0x16, - 0x91, 0xa0, 0x98, 0xb0, 0xe0, 0xe5, 0x79, 0x68, 0x56, 0x4f, 0x98, 0xb0, 0xe0, 0xf1, 0xe3, 0xe9, - 0x3f, 0xf2, 0x2c, 0x0e, 0x62, 0x5e, 0xde, 0x39, 0x63, 0x69, 0x15, 0xce, 0x31, 0xdb, 0x47, 0xab, - 0x24, 0xa7, 0x7e, 0x4a, 0x44, 0xd8, 0x6d, 0x3a, 0x68, 0xd0, 0xf4, 0x4c, 0x0e, 0x62, 0x96, 0x53, - 0x8f, 0x88, 0xf0, 0xa2, 0x79, 0xff, 0xd0, 0x37, 0xc6, 0xd3, 0xcd, 0xde, 0x46, 0xdb, 0xbd, 0x8d, - 0xde, 0xf7, 0x36, 0xba, 0x3b, 0xd8, 0xc6, 0xf6, 0x60, 0x1b, 0xaf, 0x07, 0xdb, 0xb8, 0x3e, 0x8d, - 0x20, 0x5b, 0xe4, 0xd4, 0x0d, 0x24, 0xc7, 0xd5, 0xfc, 0x63, 0x42, 0xd5, 0x10, 0x64, 0x5d, 0xe2, - 0xdb, 0xef, 0x2f, 0xcb, 0x8a, 0x84, 0x29, 0xda, 0x2a, 0xc7, 0x7a, 0xf6, 0x15, 0x00, 0x00, 0xff, - 0xff, 0xda, 0x3a, 0x9d, 0x97, 0xd3, 0x01, 0x00, 0x00, + // 420 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x44, 0x92, 0x31, 0x6f, 0xd4, 0x30, + 0x14, 0xc7, 0xe3, 0xf6, 0xe8, 0x10, 0xae, 0x03, 0xa1, 0x48, 0xd7, 0x22, 0xe5, 0x22, 0xa6, 0x13, + 0x52, 0x6d, 0x5a, 0x24, 0x06, 0xc6, 0xd3, 0x8d, 0x45, 0x3a, 0x5d, 0x91, 0x90, 0x58, 0x22, 0x3b, + 0x71, 0xdd, 0x47, 0x63, 0xbf, 0x28, 0x4e, 0x5a, 0xf2, 0x2d, 0x18, 0x3b, 0x32, 0x32, 0x32, 0xf0, + 0x21, 0x3a, 0xa1, 0x8a, 0x09, 0x31, 0x1c, 0xe8, 0x6e, 0xe0, 0x6b, 0xa0, 0xc4, 0xb1, 0x58, 0xa2, + 0xbc, 0xfc, 0xfe, 0x2f, 0xff, 0xff, 0x7b, 0x76, 0x98, 0x08, 0x2e, 0xda, 0x02, 0x0d, 0xbb, 0x00, + 0xc3, 0x0b, 0xa8, 0x5b, 0x76, 0x7d, 0xc2, 0x4a, 0x5e, 0x71, 0x6d, 0x69, 0x59, 0x61, 0x8d, 0xd1, + 0xe3, 0x41, 0x41, 0xbd, 0x82, 0x5e, 0x9f, 0x1c, 0x1d, 0x28, 0x54, 0xd8, 0x73, 0xd6, 0xbd, 0x39, + 0xe9, 0xd1, 0x23, 0xae, 0xc1, 0x20, 0xeb, 0x9f, 0xc3, 0xa7, 0xc3, 0x0c, 0xad, 0x46, 0x9b, 0x3a, + 0xad, 0x2b, 0x06, 0x14, 0x2b, 0x44, 0x55, 0x48, 0xd6, 0x57, 0xa2, 0xb9, 0x60, 0x79, 0x53, 0xf1, + 0x1a, 0xd0, 0x38, 0xfe, 0xec, 0xfb, 0x4e, 0xb8, 0xb7, 0xec, 0x93, 0x44, 0x2f, 0xc2, 0x03, 0x0b, + 0xca, 0xc8, 0x3c, 0x15, 0x05, 0x66, 0x57, 0x36, 0xbd, 0x01, 0x93, 0xe3, 0xcd, 0x84, 0x24, 0x64, + 0xb6, 0xbb, 0x8a, 0x1c, 0x9b, 0xf7, 0xe8, 0x5d, 0x4f, 0xba, 0x0e, 0x9f, 0x37, 0xb5, 0xa0, 0xd2, + 0x1a, 0xb4, 0xc4, 0xa6, 0x9e, 0xec, 0xb8, 0x0e, 0xcf, 0xce, 0x41, 0xbd, 0x75, 0x24, 0x82, 0xf0, + 0x89, 0x06, 0x93, 0x0e, 0x3e, 0xa5, 0xac, 0xbc, 0xc9, 0x6e, 0x42, 0x66, 0xe3, 0xf9, 0xab, 0xbb, + 0xf5, 0x34, 0xf8, 0xb5, 0x9e, 0x3e, 0x75, 0x33, 0xd8, 0xfc, 0x8a, 0x02, 0x32, 0xcd, 0xeb, 0x4b, + 0x7a, 0x26, 0x15, 0xcf, 0xda, 0x85, 0xcc, 0x7e, 0x7c, 0x3b, 0x0e, 0x87, 0x11, 0x17, 0x32, 0xfb, + 0xf2, 0xf7, 0xeb, 0x73, 0xb2, 0x8a, 0x34, 0x98, 0xf3, 0xfe, 0x9f, 0x4b, 0x59, 0x0d, 0xe1, 0x92, + 0x70, 0xdc, 0x59, 0x95, 0x8d, 0x48, 0x2b, 0x6e, 0xf2, 0xc9, 0x28, 0x21, 0xb3, 0xd1, 0x2a, 0xd4, + 0x60, 0x96, 0x8d, 0x58, 0x71, 0x93, 0x47, 0x6f, 0xc2, 0xfd, 0x0f, 0x1c, 0x8a, 0xd4, 0xaf, 0x64, + 0xf2, 0x20, 0x21, 0xb3, 0x87, 0xa7, 0x87, 0xd4, 0xed, 0x8c, 0xfa, 0x9d, 0xd1, 0xc5, 0x20, 0x98, + 0xef, 0x77, 0xf9, 0x6e, 0x7f, 0x4f, 0x89, 0xb3, 0x1d, 0x77, 0xed, 0x1e, 0xbe, 0x1e, 0xdd, 0x7e, + 0x9e, 0x06, 0xf3, 0xb3, 0xbb, 0x4d, 0x4c, 0xee, 0x37, 0x31, 0xf9, 0xb3, 0x89, 0xc9, 0xa7, 0x6d, + 0x1c, 0xdc, 0x6f, 0xe3, 0xe0, 0xe7, 0x36, 0x0e, 0xde, 0x9f, 0x2a, 0xa8, 0x2f, 0x1b, 0x41, 0x33, + 0xd4, 0x6c, 0x38, 0xee, 0x82, 0x0b, 0x7b, 0x0c, 0xe8, 0x4b, 0xf6, 0xf1, 0xff, 0x0d, 0xa9, 0xdb, + 0x52, 0x5a, 0xb1, 0xd7, 0x67, 0x78, 0xf9, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xf4, 0xd4, 0xa2, 0x2b, + 0x42, 0x02, 0x00, 0x00, } func (m *Params) Marshal() (dAtA []byte, err error) { @@ -147,6 +164,14 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + n1, err1 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.JailDuration, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.JailDuration):]) + if err1 != nil { + return 0, err1 + } + i -= n1 + i = encodeVarintParams(dAtA, i, uint64(n1)) + i-- + dAtA[i] = 0x2a if m.MinPubRand != 0 { i = encodeVarintParams(dAtA, i, uint64(m.MinPubRand)) i-- @@ -203,6 +228,8 @@ func (m *Params) Size() (n int) { if m.MinPubRand != 0 { n += 1 + sovParams(uint64(m.MinPubRand)) } + l = github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.JailDuration) + n += 1 + l + sovParams(uint64(l)) return n } @@ -331,6 +358,39 @@ func (m *Params) Unmarshal(dAtA []byte) error { break } } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JailDuration", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthParams + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthParams + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_cosmos_gogoproto_types.StdDurationUnmarshal(&m.JailDuration, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipParams(dAtA[iNdEx:])