diff --git a/chain/exchange/types/codec.go b/chain/exchange/types/codec.go index 58d23c09..b4a7b7a2 100644 --- a/chain/exchange/types/codec.go +++ b/chain/exchange/types/codec.go @@ -38,6 +38,7 @@ func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { cdc.RegisterConcrete(&PerpetualMarketLaunchProposal{}, "exchange/PerpetualMarketLaunchProposal", nil) cdc.RegisterConcrete(&ExpiryFuturesMarketLaunchProposal{}, "exchange/ExpiryFuturesMarketLaunchProposal", nil) cdc.RegisterConcrete(&DerivativeMarketParamUpdateProposal{}, "exchange/DerivativeMarketParamUpdateProposal", nil) + cdc.RegisterConcrete(&LiquidityMiningCampaignProposal{}, "exchange/LiquidityMiningCampaignProposal", nil) } func RegisterInterfaces(registry types.InterfaceRegistry) { @@ -71,6 +72,7 @@ func RegisterInterfaces(registry types.InterfaceRegistry) { &PerpetualMarketLaunchProposal{}, &ExpiryFuturesMarketLaunchProposal{}, &DerivativeMarketParamUpdateProposal{}, + &LiquidityMiningCampaignProposal{}, ) msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) diff --git a/chain/exchange/types/common_utils.go b/chain/exchange/types/common_utils.go index 7acbcf67..1399be6b 100644 --- a/chain/exchange/types/common_utils.go +++ b/chain/exchange/types/common_utils.go @@ -54,6 +54,9 @@ func (d *DerivativeLimitOrderDelta) OrderHash() common.Hash { var AuctionSubaccountID = common.HexToHash("0x1111111111111111111111111111111111111111111111111111111111111111") var ZeroSubaccountID = common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000") +// TempRewardsSenderAddress equals sdk.AccAddress(common.HexToAddress(AuctionSubaccountID.Hex()).Bytes()) +var TempRewardsSenderAddress, _ = sdk.AccAddressFromBech32("inj1zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3t5qxqh") + func IsValidSubaccountID(subaccountID string) (*common.Address, bool) { if len(subaccountID) != 66 { return nil, false @@ -124,10 +127,26 @@ func SdkAddressToEthAddress(addr sdk.Address) common.Address { return common.BytesToAddress(addr.Bytes()) } +func SubaccountIDToSdkAddress(subaccountID common.Hash) sdk.Address { + return sdk.AccAddress(subaccountID[:common.AddressLength]) +} + func EthAddressToSubaccountID(addr common.Address) common.Hash { return common.BytesToHash(common.RightPadBytes(addr.Bytes(), 32)) } +func DecToDecBytes(dec sdk.Dec) []byte { + return dec.BigInt().Bytes() +} + +func DecBytesToDec(bz []byte) sdk.Dec { + dec := sdk.NewDecFromBigIntWithPrec(new(big.Int).SetBytes(bz), sdk.Precision) + if dec.IsNil() { + return sdk.ZeroDec() + } + return dec +} + // PrintSpotLimitOrderbookState is a helper debugger function to print a tabular view of the spot limit orderbook fill state func PrintSpotLimitOrderbookState(buyOrderbookState *OrderbookFills, sellOrderbookState *OrderbookFills) { table := tablewriter.NewWriter(os.Stdout) @@ -169,3 +188,25 @@ func PrintSpotLimitOrderbookState(buyOrderbookState *OrderbookFills, sellOrderbo } table.Render() } + +func HasDuplicates(slice []string) bool { + seen := make(map[string]bool) + for _, item := range slice { + if seen[item] { + return true + } + seen[item] = true + } + return false +} + +func HasDuplicatesCoin(slice []sdk.Coin) bool { + seen := make(map[string]bool) + for _, item := range slice { + if seen[item.Denom] { + return true + } + seen[item.Denom] = true + } + return false +} diff --git a/chain/exchange/types/derivative_data.go b/chain/exchange/types/derivative_data.go index 0b63fe8e..62d079a3 100644 --- a/chain/exchange/types/derivative_data.go +++ b/chain/exchange/types/derivative_data.go @@ -20,12 +20,13 @@ type DerivativeOrderStateExpansion struct { TotalBalanceDelta sdk.Dec AvailableBalanceDelta sdk.Dec - AuctionFeeReward sdk.Dec - FeeRecipientReward sdk.Dec - FeeRecipient common.Address - LimitOrderFilledDelta *DerivativeLimitOrderDelta - MarketOrderFilledDelta *DerivativeMarketOrderDelta - OrderHash common.Hash + AuctionFeeReward sdk.Dec + LiquidityMiningRewardPoints sdk.Dec + FeeRecipientReward sdk.Dec + FeeRecipient common.Address + LimitOrderFilledDelta *DerivativeLimitOrderDelta + MarketOrderFilledDelta *DerivativeMarketOrderDelta + OrderHash common.Hash } func ApplyDeltasAndGetDerivativeOrderBatchEvent( @@ -35,6 +36,7 @@ func ApplyDeltasAndGetDerivativeOrderBatchEvent( funding *PerpetualMarketFunding, stateExpansions []*DerivativeOrderStateExpansion, depositDeltas DepositDeltas, + liquidityMiningRewards LiquidityMiningRewards, ) (batch *EventBatchDerivativeExecution, filledDeltas []*DerivativeLimitOrderDelta) { if len(stateExpansions) == 0 { return @@ -61,6 +63,11 @@ func ApplyDeltasAndGetDerivativeOrderBatchEvent( depositDeltas.ApplyUniformDelta(feeRecipientSubaccount, expansion.FeeRecipientReward) depositDeltas.ApplyUniformDelta(AuctionSubaccountID, expansion.AuctionFeeReward) + sender := SubaccountIDToSdkAddress(expansion.SubaccountID) + if expansion.LiquidityMiningRewardPoints.IsPositive() { + liquidityMiningRewards.AddPointsForAddress(sender.String(), expansion.LiquidityMiningRewardPoints) + } + if !executionType.IsMarket() { filledDeltas = append(filledDeltas, expansion.LimitOrderFilledDelta) } diff --git a/chain/exchange/types/derivative_execution.go b/chain/exchange/types/derivative_execution.go index 874f2af7..52860637 100644 --- a/chain/exchange/types/derivative_execution.go +++ b/chain/exchange/types/derivative_execution.go @@ -15,6 +15,8 @@ type DerivativeBatchExecutionData struct { DepositDeltas DepositDeltas DepositSubaccountIDs []common.Hash + LiquidityMiningRewards LiquidityMiningRewards + // updated positions Positions []*Position PositionSubaccountIDs []common.Hash @@ -106,16 +108,17 @@ func (e *DerivativeMatchingExpansionData) GetLimitMatchingDerivativeBatchExecuti positionStates map[common.Hash]*PositionState, ) *DerivativeBatchExecutionData { depositDeltas := NewDepositDeltas() + liquidityMiningRewards := NewLiquidityMiningRewards() // process undermargined resting limit order forced cancellations cancelLimitOrdersEvents, restingOrderCancelledDeltas, transientOrderCancelledDeltas := e.applyCancellationsAndGetDerivativeLimitCancelEvents(market.MarketID(), market.MakerFeeRate, market.TakerFeeRate, depositDeltas) positions, positionSubaccountIDs := GetPositionSliceData(positionStates) - transientLimitBuyOrderBatchEvent, transientLimitBuyFilledDeltas := ApplyDeltasAndGetDerivativeOrderBatchEvent(true, ExecutionType_LimitMatchNewOrder, market, funding, e.TransientLimitBuyExpansions, depositDeltas) - restingLimitBuyOrderBatchEvent, restingLimitBuyFilledDeltas := ApplyDeltasAndGetDerivativeOrderBatchEvent(true, ExecutionType_LimitMatchRestingOrder, market, funding, e.RestingLimitBuyExpansions, depositDeltas) - transientLimitSellOrderBatchEvent, transientLimitSellFilledDeltas := ApplyDeltasAndGetDerivativeOrderBatchEvent(false, ExecutionType_LimitMatchNewOrder, market, funding, e.TransientLimitSellExpansions, depositDeltas) - restingLimitSellOrderBatchEvent, restingLimitSellFilledDeltas := ApplyDeltasAndGetDerivativeOrderBatchEvent(false, ExecutionType_LimitMatchRestingOrder, market, funding, e.RestingLimitSellExpansions, depositDeltas) + transientLimitBuyOrderBatchEvent, transientLimitBuyFilledDeltas := ApplyDeltasAndGetDerivativeOrderBatchEvent(true, ExecutionType_LimitMatchNewOrder, market, funding, e.TransientLimitBuyExpansions, depositDeltas, liquidityMiningRewards) + restingLimitBuyOrderBatchEvent, restingLimitBuyFilledDeltas := ApplyDeltasAndGetDerivativeOrderBatchEvent(true, ExecutionType_LimitMatchRestingOrder, market, funding, e.RestingLimitBuyExpansions, depositDeltas, liquidityMiningRewards) + transientLimitSellOrderBatchEvent, transientLimitSellFilledDeltas := ApplyDeltasAndGetDerivativeOrderBatchEvent(false, ExecutionType_LimitMatchNewOrder, market, funding, e.TransientLimitSellExpansions, depositDeltas, liquidityMiningRewards) + restingLimitSellOrderBatchEvent, restingLimitSellFilledDeltas := ApplyDeltasAndGetDerivativeOrderBatchEvent(false, ExecutionType_LimitMatchRestingOrder, market, funding, e.RestingLimitSellExpansions, depositDeltas, liquidityMiningRewards) restingOrderFilledDeltas := mergeDerivativeLimitOrderFilledDeltas(restingLimitBuyFilledDeltas, restingLimitSellFilledDeltas) transientOrderFilledDeltas := mergeDerivativeLimitOrderFilledDeltas(transientLimitBuyFilledDeltas, transientLimitSellFilledDeltas) @@ -144,6 +147,7 @@ func (e *DerivativeMatchingExpansionData) GetLimitMatchingDerivativeBatchExecuti Funding: funding, DepositDeltas: depositDeltas, DepositSubaccountIDs: depositDeltaKeys, + LiquidityMiningRewards: liquidityMiningRewards, Positions: positions, PositionSubaccountIDs: positionSubaccountIDs, RestingLimitOrderFilledDeltas: restingOrderFilledDeltas, @@ -339,6 +343,7 @@ func (e *DerivativeMarketOrderExpansionData) GetMarketDerivativeBatchExecutionDa positionStates map[common.Hash]*PositionState, ) *DerivativeBatchExecutionData { depositDeltas := NewDepositDeltas() + liquidityMiningRewards := NewLiquidityMiningRewards() // process undermargined limit order forced cancellations cancelLimitOrdersEvents, restingOrderCancelledDeltas := e.applyCancellationsAndGetDerivativeLimitCancelEvents(market.MarketID(), market.MakerFeeRate, depositDeltas) @@ -348,10 +353,10 @@ func (e *DerivativeMarketOrderExpansionData) GetMarketDerivativeBatchExecutionDa positions, positionSubaccountIDs := GetPositionSliceData(positionStates) - buyMarketOrderBatchEvent, _ := ApplyDeltasAndGetDerivativeOrderBatchEvent(true, ExecutionType_Market, market, funding, e.MarketBuyExpansions, depositDeltas) - sellMarketOrderBatchEvent, _ := ApplyDeltasAndGetDerivativeOrderBatchEvent(false, ExecutionType_Market, market, funding, e.MarketSellExpansions, depositDeltas) - restingLimitBuyOrderBatchEvent, limitBuyFilledDeltas := ApplyDeltasAndGetDerivativeOrderBatchEvent(true, ExecutionType_LimitFill, market, funding, e.LimitBuyExpansions, depositDeltas) - restingLimitSellOrderBatchEvent, limitSellFilledDeltas := ApplyDeltasAndGetDerivativeOrderBatchEvent(false, ExecutionType_LimitFill, market, funding, e.LimitSellExpansions, depositDeltas) + buyMarketOrderBatchEvent, _ := ApplyDeltasAndGetDerivativeOrderBatchEvent(true, ExecutionType_Market, market, funding, e.MarketBuyExpansions, depositDeltas, liquidityMiningRewards) + sellMarketOrderBatchEvent, _ := ApplyDeltasAndGetDerivativeOrderBatchEvent(false, ExecutionType_Market, market, funding, e.MarketSellExpansions, depositDeltas, liquidityMiningRewards) + restingLimitBuyOrderBatchEvent, limitBuyFilledDeltas := ApplyDeltasAndGetDerivativeOrderBatchEvent(true, ExecutionType_LimitFill, market, funding, e.LimitBuyExpansions, depositDeltas, liquidityMiningRewards) + restingLimitSellOrderBatchEvent, limitSellFilledDeltas := ApplyDeltasAndGetDerivativeOrderBatchEvent(false, ExecutionType_LimitFill, market, funding, e.LimitSellExpansions, depositDeltas, liquidityMiningRewards) filledDeltas := mergeDerivativeLimitOrderFilledDeltas(limitBuyFilledDeltas, limitSellFilledDeltas) @@ -371,6 +376,7 @@ func (e *DerivativeMarketOrderExpansionData) GetMarketDerivativeBatchExecutionDa Funding: funding, DepositDeltas: depositDeltas, DepositSubaccountIDs: depositDeltaKeys, + LiquidityMiningRewards: liquidityMiningRewards, Positions: positions, PositionSubaccountIDs: positionSubaccountIDs, TransientLimitOrderFilledDeltas: nil, diff --git a/chain/exchange/types/errors.go b/chain/exchange/types/errors.go index 948f2886..ac1e9951 100644 --- a/chain/exchange/types/errors.go +++ b/chain/exchange/types/errors.go @@ -9,7 +9,7 @@ var ( ErrSpotMarketNotFound = sdkerrors.Register(ModuleName, 2, "spot market not found") ErrSpotMarketExists = sdkerrors.Register(ModuleName, 3, "spot market exists") ErrBadField = sdkerrors.Register(ModuleName, 4, "struct field error") - ErrMarketInvalid = sdkerrors.Register(ModuleName, 5, "failed to validate derivative market") + ErrMarketInvalid = sdkerrors.Register(ModuleName, 5, "failed to validate market") ErrInsufficientDeposit = sdkerrors.Register(ModuleName, 6, "subaccount has insufficient deposits") ErrUnrecognizedOrderType = sdkerrors.Register(ModuleName, 7, "unrecognized order type") ErrInsufficientPositionQuantity = sdkerrors.Register(ModuleName, 8, "position quantity insufficient for order") @@ -57,4 +57,8 @@ var ( ErrInvalidHourlyInterestRate = sdkerrors.Register(ModuleName, 50, "Invalid hourly interest rate") ErrInvalidHourlyFundingRateCap = sdkerrors.Register(ModuleName, 51, "Invalid hourly funding rate cap") ErrInvalidMarketFundingParamUpdate = sdkerrors.Register(ModuleName, 52, "Only perpetual markets can update funding parameters") + ErrInvalidLiquidityMiningMarket = sdkerrors.Register(ModuleName, 53, "Invalid liquidity mining market") + ErrInvalidLiquidityMiningMarketWeights = sdkerrors.Register(ModuleName, 54, "Invalid liquidity mining market weights") + ErrInvalidLiquidityMiningCampaign = sdkerrors.Register(ModuleName, 55, "Invalid liquidity mining campaign") + ErrInvalidLiquidityMiningReward = sdkerrors.Register(ModuleName, 56, "Invalid liquidity mining reward") ) diff --git a/chain/exchange/types/exchange.pb.go b/chain/exchange/types/exchange.pb.go index 8aae56c2..74b18c90 100644 --- a/chain/exchange/types/exchange.pb.go +++ b/chain/exchange/types/exchange.pb.go @@ -735,7 +735,7 @@ func (m *SpotMarket) GetStatus() MarketStatus { return MarketStatus_Unspecified } -// An subaccount's deposit for a given base currency +// A subaccount's deposit for a given base currency type Deposit struct { AvailableBalance github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=available_balance,json=availableBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"available_balance"` TotalBalance github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=total_balance,json=totalBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"total_balance"` @@ -2784,6 +2784,73 @@ func (m *EventCancelDerivativeOrder) GetMarketOrderCancel() *DerivativeMarketOrd return nil } +type LiquidityMiningCampaign struct { + // spot_market_ids are the marketIDs of the active spot markets in the liquidity mining campaign + SpotMarketIds []string `protobuf:"bytes,1,rep,name=spot_market_ids,json=spotMarketIds,proto3" json:"spot_market_ids,omitempty"` + // spot_market_weights are the weights for the spot markets + SpotMarketWeights []github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,rep,name=spot_market_weights,json=spotMarketWeights,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"spot_market_weights"` + // derivative_market_ids are the marketIDs of the active derivative markets in the liquidity mining campaign + DerivativeMarketIds []string `protobuf:"bytes,3,rep,name=derivative_market_ids,json=derivativeMarketIds,proto3" json:"derivative_market_ids,omitempty"` + // derivative_market_weights are the weights for the derivative markets + DerivativeMarketWeights []github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,rep,name=derivative_market_weights,json=derivativeMarketWeights,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"derivative_market_weights"` + // max_epoch_rewards are the maximum reward amounts to be disbursed at the end of the epoch + MaxEpochRewards github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,5,rep,name=max_epoch_rewards,json=maxEpochRewards,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"max_epoch_rewards"` +} + +func (m *LiquidityMiningCampaign) Reset() { *m = LiquidityMiningCampaign{} } +func (m *LiquidityMiningCampaign) String() string { return proto.CompactTextString(m) } +func (*LiquidityMiningCampaign) ProtoMessage() {} +func (*LiquidityMiningCampaign) Descriptor() ([]byte, []int) { + return fileDescriptor_2116e2804e9c53f9, []int{44} +} +func (m *LiquidityMiningCampaign) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LiquidityMiningCampaign) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LiquidityMiningCampaign.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 *LiquidityMiningCampaign) XXX_Merge(src proto.Message) { + xxx_messageInfo_LiquidityMiningCampaign.Merge(m, src) +} +func (m *LiquidityMiningCampaign) XXX_Size() int { + return m.Size() +} +func (m *LiquidityMiningCampaign) XXX_DiscardUnknown() { + xxx_messageInfo_LiquidityMiningCampaign.DiscardUnknown(m) +} + +var xxx_messageInfo_LiquidityMiningCampaign proto.InternalMessageInfo + +func (m *LiquidityMiningCampaign) GetSpotMarketIds() []string { + if m != nil { + return m.SpotMarketIds + } + return nil +} + +func (m *LiquidityMiningCampaign) GetDerivativeMarketIds() []string { + if m != nil { + return m.DerivativeMarketIds + } + return nil +} + +func (m *LiquidityMiningCampaign) GetMaxEpochRewards() github_com_cosmos_cosmos_sdk_types.Coins { + if m != nil { + return m.MaxEpochRewards + } + return nil +} + func init() { proto.RegisterEnum("injective.exchange.v1beta1.MarketStatus", MarketStatus_name, MarketStatus_value) proto.RegisterEnum("injective.exchange.v1beta1.OrderType", OrderType_name, OrderType_value) @@ -2832,6 +2899,7 @@ func init() { proto.RegisterType((*EventBatchDepositUpdate)(nil), "injective.exchange.v1beta1.EventBatchDepositUpdate") proto.RegisterType((*DerivativeMarketOrderCancel)(nil), "injective.exchange.v1beta1.DerivativeMarketOrderCancel") proto.RegisterType((*EventCancelDerivativeOrder)(nil), "injective.exchange.v1beta1.EventCancelDerivativeOrder") + proto.RegisterType((*LiquidityMiningCampaign)(nil), "injective.exchange.v1beta1.LiquidityMiningCampaign") } func init() { @@ -2839,207 +2907,215 @@ func init() { } var fileDescriptor_2116e2804e9c53f9 = []byte{ - // 3185 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x5b, 0xcd, 0x6f, 0x1b, 0xc7, - 0x15, 0xf7, 0x92, 0x12, 0x4d, 0x3e, 0x92, 0x22, 0x35, 0xa2, 0x65, 0x5a, 0xb2, 0x25, 0x79, 0x13, - 0x07, 0x8e, 0x91, 0x48, 0xb1, 0x53, 0x20, 0x6d, 0xd1, 0x00, 0x8e, 0x2c, 0x09, 0x91, 0x23, 0x5b, - 0xf2, 0x52, 0xae, 0xe1, 0x14, 0xc6, 0x66, 0xb5, 0x3b, 0x12, 0xa7, 0xde, 0x0f, 0x7a, 0x67, 0x29, - 0x5b, 0x49, 0x4f, 0xbd, 0xd5, 0x97, 0x16, 0xe8, 0xa1, 0xe9, 0xc1, 0x40, 0xd1, 0x4b, 0x7b, 0x6c, - 0x81, 0xa2, 0x97, 0xfc, 0x01, 0x49, 0x4f, 0x0d, 0x7a, 0x2a, 0xda, 0x34, 0x28, 0x9c, 0x02, 0xed, - 0xb5, 0xed, 0xa9, 0x28, 0x0a, 0x14, 0xf3, 0xb1, 0x1f, 0xfc, 0x30, 0x25, 0x2d, 0x69, 0xf4, 0xe3, - 0x24, 0xee, 0xcc, 0xbc, 0xdf, 0x9b, 0xf7, 0xe6, 0x7d, 0xcd, 0xdb, 0x15, 0xbc, 0x4c, 0xdc, 0x6f, - 0x62, 0x33, 0x20, 0xfb, 0x78, 0x09, 0x3f, 0x32, 0x9b, 0x86, 0xbb, 0x87, 0x97, 0xf6, 0x2f, 0xef, - 0xe0, 0xc0, 0xb8, 0x1c, 0x0d, 0x2c, 0xb6, 0x7c, 0x2f, 0xf0, 0xd0, 0x4c, 0xb4, 0x74, 0x31, 0x9a, - 0x91, 0x4b, 0x67, 0x6a, 0x7b, 0xde, 0x9e, 0xc7, 0x97, 0x2d, 0xb1, 0x5f, 0x82, 0x62, 0x66, 0xce, - 0xf4, 0xa8, 0xe3, 0xd1, 0xa5, 0x1d, 0x83, 0xc6, 0xa8, 0xa6, 0x47, 0x5c, 0x39, 0x7f, 0x21, 0x66, - 0xee, 0xf9, 0x86, 0x69, 0xc7, 0x8b, 0xc4, 0xa3, 0x58, 0xa6, 0xfe, 0xb0, 0x08, 0xb9, 0x2d, 0xc3, - 0x37, 0x1c, 0x8a, 0x30, 0xcc, 0xd3, 0x96, 0x17, 0xe8, 0x8e, 0xe1, 0xdf, 0xc7, 0x81, 0x4e, 0x5c, - 0x1a, 0x18, 0x6e, 0xa0, 0xdb, 0x84, 0x06, 0xc4, 0xdd, 0xd3, 0x77, 0x31, 0xae, 0x2b, 0x0b, 0xca, - 0xc5, 0xe2, 0x95, 0x33, 0x8b, 0x82, 0xf7, 0x22, 0xe3, 0x1d, 0x6e, 0x73, 0xf1, 0x9a, 0x47, 0xdc, - 0xe5, 0xb1, 0x4f, 0x3e, 0x9f, 0x3f, 0xa1, 0xcd, 0x32, 0x9c, 0x1b, 0x1c, 0x66, 0x5d, 0xa0, 0x6c, - 0x08, 0x90, 0x35, 0x8c, 0xd1, 0x03, 0xb8, 0x60, 0x61, 0x9f, 0xec, 0x1b, 0x6c, 0x6f, 0x83, 0x98, - 0x65, 0x8e, 0xc6, 0xec, 0x7c, 0x8c, 0xf6, 0x2c, 0x96, 0x36, 0xcc, 0x5a, 0x78, 0xd7, 0x68, 0xdb, - 0x81, 0x2e, 0x25, 0xbc, 0x8f, 0x7d, 0xc6, 0x43, 0xf7, 0x8d, 0x00, 0xd7, 0xb3, 0x0b, 0xca, 0xc5, - 0xc2, 0xf2, 0x22, 0x43, 0xfb, 0xdd, 0xe7, 0xf3, 0x2f, 0xed, 0x91, 0xa0, 0xd9, 0xde, 0x59, 0x34, - 0x3d, 0x67, 0x49, 0xea, 0x58, 0xfc, 0x79, 0x95, 0x5a, 0xf7, 0x97, 0x82, 0x83, 0x16, 0xa6, 0x8b, - 0x2b, 0xd8, 0xd4, 0x4e, 0x4b, 0xc8, 0x06, 0x97, 0xf5, 0x3e, 0xf6, 0xd7, 0x30, 0xd6, 0x8c, 0xa0, - 0x97, 0x5b, 0xd0, 0xc9, 0x6d, 0x6c, 0x68, 0x6e, 0xdb, 0x49, 0x6e, 0x8f, 0xe0, 0x7c, 0xc8, 0xad, - 0x43, 0xad, 0x1d, 0x3c, 0xc7, 0x53, 0xf1, 0x3c, 0x27, 0x81, 0x57, 0x12, 0x0a, 0x3e, 0x94, 0x73, - 0x97, 0xb4, 0xb9, 0x11, 0x71, 0xee, 0x90, 0xd9, 0x83, 0xb3, 0x21, 0x67, 0xe2, 0x92, 0x80, 0x18, - 0x36, 0xb3, 0xa3, 0x3d, 0xe2, 0x32, 0x9e, 0xc4, 0xab, 0x9f, 0x4c, 0xc5, 0xf4, 0x8c, 0xc4, 0x5c, - 0x17, 0x90, 0x37, 0x38, 0xa2, 0xc6, 0x00, 0xd1, 0x43, 0x58, 0x08, 0x19, 0x3a, 0x06, 0x71, 0x03, - 0xec, 0x1a, 0xae, 0x89, 0x3b, 0x99, 0xe6, 0x87, 0x92, 0xf4, 0x46, 0x0c, 0x9b, 0x64, 0xfc, 0x65, - 0xa8, 0x87, 0x8c, 0x77, 0xdb, 0xae, 0xc5, 0x5c, 0x83, 0xad, 0xf3, 0xf7, 0x0d, 0xbb, 0x5e, 0x58, - 0x50, 0x2e, 0x66, 0xb5, 0x69, 0x39, 0xbf, 0x26, 0xa6, 0xd7, 0xe5, 0x2c, 0x7a, 0x19, 0xaa, 0x21, - 0x85, 0xd3, 0xb6, 0x03, 0xd2, 0xb2, 0x71, 0x1d, 0x38, 0x45, 0x45, 0x8e, 0xdf, 0x90, 0xc3, 0xc8, - 0x84, 0x69, 0x1f, 0xdb, 0xc6, 0x81, 0x3c, 0x37, 0xda, 0x34, 0x7c, 0x79, 0x7a, 0xc5, 0x54, 0x32, - 0x4d, 0x49, 0xb4, 0x35, 0x8c, 0x1b, 0x0c, 0x8b, 0x9f, 0x59, 0x00, 0xf3, 0xa1, 0x24, 0x4d, 0xaf, - 0xed, 0xdb, 0x07, 0x91, 0x40, 0x8c, 0x93, 0x6e, 0x1a, 0xad, 0x7a, 0x29, 0x15, 0xb7, 0xd0, 0xd9, - 0xde, 0xe6, 0xa8, 0x52, 0x0d, 0x8c, 0xe5, 0x35, 0xa3, 0x95, 0xb4, 0x14, 0xc9, 0x95, 0xab, 0x0f, - 0xd3, 0x40, 0x08, 0x58, 0x1e, 0xca, 0x52, 0x04, 0xcb, 0x75, 0x89, 0xc8, 0xc5, 0x5c, 0x81, 0x79, - 0xc7, 0x78, 0x94, 0x74, 0x08, 0xcf, 0xb7, 0xb0, 0xaf, 0x53, 0x62, 0x61, 0xdd, 0xf4, 0xda, 0x6e, - 0x50, 0x9f, 0x58, 0x50, 0x2e, 0x96, 0xb5, 0x59, 0xc7, 0x78, 0x14, 0x9b, 0xf7, 0x26, 0x5b, 0xd4, - 0x20, 0x16, 0xbe, 0xc6, 0x96, 0x7c, 0x75, 0xec, 0x2f, 0x3f, 0x9a, 0x57, 0xd4, 0x9f, 0xe6, 0xa1, - 0xba, 0xd2, 0x15, 0xdc, 0xd0, 0x34, 0xe4, 0x02, 0x62, 0xde, 0xc7, 0x3e, 0x0f, 0xc6, 0x05, 0x4d, - 0x3e, 0xa1, 0x79, 0x28, 0x8a, 0xc0, 0xae, 0xb3, 0x40, 0xc9, 0x83, 0x67, 0x41, 0x03, 0x31, 0xb4, - 0x6c, 0x50, 0x8c, 0xce, 0x43, 0x49, 0x2e, 0x78, 0xd0, 0xf6, 0xc2, 0xa8, 0xa7, 0x49, 0xa2, 0x5b, - 0x6c, 0x08, 0xad, 0x46, 0x18, 0x4c, 0x56, 0x1e, 0xa9, 0x26, 0xae, 0xbc, 0xb8, 0x18, 0xe7, 0x26, - 0x99, 0x3a, 0xc2, 0x28, 0xbc, 0xc9, 0x1f, 0xb7, 0x0f, 0x5a, 0x38, 0xe4, 0xc4, 0x7e, 0xa3, 0x45, - 0x98, 0x92, 0x30, 0xd4, 0x34, 0x6c, 0xac, 0xef, 0x1a, 0x66, 0xe0, 0xf9, 0x3c, 0x08, 0x95, 0xb5, - 0x49, 0x31, 0xd5, 0x60, 0x33, 0x6b, 0x7c, 0x82, 0x6d, 0x9d, 0x6f, 0x49, 0xb7, 0xb0, 0xeb, 0x39, - 0x22, 0x64, 0x68, 0xc0, 0x87, 0x56, 0xd8, 0x08, 0x9a, 0x85, 0x42, 0x98, 0x27, 0x2c, 0xe1, 0xdc, - 0x5a, 0x5e, 0x0c, 0xac, 0x5b, 0xe8, 0x3d, 0xa8, 0xf5, 0x0d, 0x02, 0xe9, 0xfc, 0x11, 0x91, 0x5e, - 0xef, 0x6f, 0x42, 0xfd, 0x99, 0x5e, 0x5f, 0x48, 0xc5, 0x65, 0xda, 0xe9, 0xef, 0xee, 0xdb, 0x30, - 0xd1, 0x15, 0xb9, 0x21, 0x15, 0x7e, 0xc9, 0x49, 0x86, 0xcb, 0x6d, 0x98, 0xe8, 0x8a, 0xca, 0xe9, - 0xfc, 0xba, 0x14, 0x24, 0x51, 0x9f, 0x1d, 0x35, 0x4a, 0xa3, 0x8b, 0x1a, 0x0b, 0x50, 0x24, 0x74, - 0x0b, 0xfb, 0x2d, 0x1c, 0xb4, 0x0d, 0x9b, 0xbb, 0x6b, 0x5e, 0x4b, 0x0e, 0xa1, 0xab, 0x90, 0xa3, - 0x81, 0x11, 0xb4, 0x29, 0xf7, 0xab, 0x89, 0x2b, 0x17, 0x17, 0x9f, 0x5d, 0x4a, 0x2d, 0x0a, 0x1f, - 0x6a, 0xf0, 0xf5, 0x9a, 0xa4, 0x43, 0xf7, 0x60, 0xca, 0x21, 0xae, 0xde, 0xf2, 0x89, 0x89, 0x75, - 0xe6, 0x4d, 0x3a, 0x25, 0xef, 0xe3, 0x7a, 0x25, 0x95, 0x14, 0x55, 0x87, 0xb8, 0x5b, 0x0c, 0x69, - 0x9b, 0x98, 0xf7, 0x1b, 0xe4, 0x7d, 0xae, 0x27, 0x06, 0xff, 0xa0, 0x6d, 0xb8, 0x01, 0x09, 0x0e, - 0x12, 0x1c, 0xaa, 0xe9, 0xf4, 0xe4, 0x10, 0xf7, 0x96, 0x04, 0x0b, 0x99, 0xa8, 0xff, 0xcc, 0xc0, - 0xe9, 0xd5, 0x47, 0x2d, 0xe2, 0x1f, 0xac, 0xb5, 0x83, 0xb6, 0x8f, 0x69, 0x58, 0x0a, 0xed, 0x7a, - 0x9d, 0xde, 0xa3, 0x74, 0x79, 0xcf, 0x65, 0xa8, 0x61, 0x46, 0xc7, 0xcc, 0xcf, 0xd5, 0x03, 0xe2, - 0x60, 0x1a, 0x18, 0x4e, 0x8b, 0xc7, 0x8f, 0xac, 0x36, 0x15, 0xcf, 0x6d, 0x87, 0x53, 0xe8, 0x35, - 0xa8, 0x05, 0x0f, 0x8d, 0x96, 0x4e, 0x03, 0xc3, 0x0f, 0x12, 0x24, 0x59, 0x4e, 0x82, 0xd8, 0x5c, - 0x83, 0x4d, 0xc5, 0x14, 0xdf, 0x56, 0xe0, 0xa5, 0x24, 0x97, 0x98, 0x5a, 0x28, 0xdd, 0x6c, 0x3b, - 0x6d, 0x9b, 0x07, 0xb9, 0x94, 0xd5, 0x91, 0x9a, 0xd8, 0x67, 0xc8, 0x9e, 0x9f, 0xc2, 0xb5, 0x08, - 0x19, 0xdd, 0x85, 0x2a, 0xc5, 0x41, 0x60, 0x63, 0x07, 0xbb, 0x92, 0x71, 0xca, 0xba, 0xa8, 0x12, - 0xe3, 0x70, 0x26, 0xea, 0x67, 0x19, 0x98, 0x8a, 0x2c, 0xf2, 0xa8, 0x9a, 0xc7, 0x70, 0xfa, 0x59, - 0x89, 0x30, 0x93, 0x6a, 0x5b, 0xb5, 0x66, 0xbf, 0x0c, 0xf8, 0x1e, 0xd4, 0xfa, 0x66, 0xbe, 0x74, - 0x45, 0x2f, 0x6a, 0xf6, 0xa6, 0xbc, 0x2f, 0xc1, 0xb4, 0x8b, 0x1f, 0xc5, 0x05, 0x4a, 0x6c, 0x11, - 0x63, 0xdc, 0x22, 0x6a, 0x6c, 0x56, 0xee, 0x2a, 0xb6, 0x89, 0x44, 0x7d, 0x12, 0x55, 0x34, 0xe3, - 0x1d, 0xf5, 0x49, 0x58, 0xca, 0xa8, 0xff, 0x50, 0x60, 0xba, 0x4b, 0xbd, 0x12, 0x0e, 0xdd, 0x03, - 0x14, 0x1b, 0x4f, 0xb8, 0x03, 0xa1, 0xea, 0x63, 0xcb, 0x36, 0x19, 0x23, 0x85, 0xf0, 0x77, 0xa1, - 0x9a, 0x80, 0x17, 0x36, 0x93, 0xee, 0x70, 0x2a, 0x31, 0x0e, 0xb7, 0x19, 0x74, 0x01, 0x26, 0x6c, - 0x83, 0xf6, 0xfa, 0x4f, 0x99, 0x8d, 0x46, 0x6a, 0x52, 0xff, 0xae, 0xc0, 0x5c, 0x77, 0x0d, 0xd0, - 0x88, 0xcc, 0xef, 0x70, 0x2b, 0xeb, 0x67, 0xf5, 0x99, 0x91, 0x58, 0x3d, 0x87, 0x66, 0x8e, 0xc6, - 0x8e, 0xd0, 0xc2, 0xbb, 0xc4, 0x24, 0x41, 0x4a, 0xab, 0xaa, 0x84, 0x38, 0x2b, 0x02, 0x46, 0x7d, - 0x13, 0x6a, 0x37, 0xfb, 0x19, 0xcd, 0x05, 0x98, 0xe0, 0xa6, 0x16, 0x2b, 0x4d, 0x11, 0x4a, 0x63, - 0xa3, 0xb1, 0xd2, 0x3e, 0x1c, 0x07, 0x68, 0x44, 0x57, 0xd0, 0x67, 0x96, 0x4c, 0xe7, 0x00, 0x58, - 0xad, 0x24, 0xcb, 0x0e, 0x51, 0x31, 0x15, 0xd8, 0x88, 0xa8, 0x3a, 0xba, 0xca, 0x92, 0x6c, 0x4f, - 0x59, 0xd2, 0x9b, 0xad, 0xc7, 0x9e, 0x4b, 0xb6, 0x1e, 0x7f, 0xae, 0xd9, 0x3a, 0x37, 0xba, 0x6c, - 0x3d, 0xb0, 0x4e, 0x8b, 0x13, 0x75, 0x7e, 0xb4, 0x89, 0xba, 0xf0, 0xdc, 0x13, 0x35, 0x8c, 0x2e, - 0x51, 0x7f, 0xa4, 0xc0, 0xc9, 0x15, 0xdc, 0xf2, 0x28, 0x09, 0xd0, 0x37, 0x60, 0xd2, 0xd8, 0x37, - 0x88, 0x6d, 0xec, 0xf0, 0xaa, 0xdd, 0x66, 0xd5, 0x60, 0xca, 0xd8, 0x55, 0x8d, 0x80, 0x96, 0x05, - 0x0e, 0x6a, 0x40, 0x39, 0xf0, 0x02, 0xc3, 0x8e, 0x80, 0x33, 0x29, 0xad, 0x88, 0x81, 0x48, 0x50, - 0xf5, 0x15, 0xa8, 0x35, 0xda, 0x3b, 0x86, 0xc9, 0x2f, 0x32, 0xdb, 0xbe, 0x61, 0xe1, 0x9b, 0x1e, - 0x63, 0x56, 0x83, 0x71, 0xd7, 0x0b, 0x77, 0x5f, 0xd6, 0xc4, 0x83, 0xfa, 0x67, 0x05, 0x0a, 0xfc, - 0x62, 0xc3, 0xc3, 0xd4, 0x0b, 0x50, 0xa6, 0x11, 0x6d, 0x1c, 0xaa, 0x4a, 0xf1, 0xe0, 0xba, 0xc5, - 0x16, 0x71, 0xb3, 0xc7, 0x26, 0x69, 0x11, 0xec, 0x06, 0xd2, 0x2b, 0x4b, 0xbb, 0x18, 0x6b, 0xe1, - 0x18, 0x5a, 0x81, 0x71, 0x11, 0xc8, 0xd2, 0x45, 0x1b, 0x41, 0x8c, 0xae, 0x43, 0x3e, 0x3c, 0xea, - 0x94, 0x7e, 0x1b, 0xd1, 0xab, 0xdf, 0xcd, 0x40, 0x81, 0x05, 0x1c, 0x2e, 0xed, 0xe0, 0x80, 0x7c, - 0x1d, 0x40, 0xdc, 0x08, 0x89, 0xbb, 0xeb, 0xc9, 0x1e, 0xd7, 0x85, 0x41, 0xae, 0x10, 0x69, 0x50, - 0xf6, 0xbb, 0x0a, 0x5e, 0xa4, 0xd2, 0x95, 0x10, 0x8b, 0x5f, 0xd7, 0xb2, 0xdc, 0xad, 0x0e, 0xc7, - 0xe2, 0xf7, 0x35, 0x81, 0xc2, 0xaf, 0x6b, 0xcc, 0x52, 0x7c, 0xb2, 0xb7, 0x87, 0x7d, 0x99, 0x1f, - 0x62, 0x6d, 0x28, 0xc7, 0xb2, 0x14, 0x01, 0x22, 0x4a, 0xa2, 0xa7, 0x19, 0x98, 0x60, 0x1a, 0xd9, - 0x20, 0x0e, 0x91, 0x6a, 0xe9, 0x94, 0x5c, 0x19, 0xa1, 0xe4, 0x99, 0x94, 0x92, 0x5f, 0x87, 0xfc, - 0x2e, 0xb1, 0xb9, 0xdb, 0xa4, 0xb4, 0xa5, 0x88, 0xfe, 0xb9, 0x68, 0x91, 0x65, 0x28, 0x21, 0x66, - 0xd3, 0xa0, 0x4d, 0x9e, 0x07, 0x4a, 0x72, 0xff, 0x6f, 0x1b, 0xb4, 0xa9, 0xfe, 0x5a, 0x81, 0x4a, - 0x9c, 0xe7, 0x46, 0xaf, 0xe5, 0x5b, 0x50, 0x92, 0xd1, 0x43, 0x6f, 0x7a, 0xb6, 0x95, 0x32, 0x84, - 0x14, 0x25, 0xc6, 0xdb, 0x9e, 0x6d, 0x75, 0x49, 0x94, 0xed, 0x96, 0xe8, 0x0f, 0x19, 0xa8, 0x74, - 0x75, 0x45, 0xfe, 0xd7, 0xdc, 0x69, 0x0d, 0x72, 0xa2, 0x43, 0x90, 0x32, 0xaa, 0x48, 0xea, 0x5e, - 0x83, 0x1a, 0x1f, 0x81, 0x5b, 0xfe, 0x2b, 0x03, 0xb3, 0x71, 0x04, 0xe7, 0xfb, 0xdf, 0xf1, 0xbc, - 0xfb, 0x37, 0x70, 0x60, 0x58, 0x46, 0x60, 0xa0, 0xaf, 0xc0, 0x99, 0x7d, 0xc3, 0x65, 0x36, 0xad, - 0xdb, 0xcc, 0x73, 0x65, 0xf7, 0x4a, 0x34, 0xae, 0x44, 0x70, 0x9f, 0x96, 0x0b, 0x62, 0xcf, 0xe6, - 0x3d, 0x2b, 0x74, 0x15, 0xce, 0xf9, 0xd8, 0x6a, 0x9b, 0x58, 0xf7, 0x5c, 0xfb, 0xa0, 0x0f, 0x79, - 0x86, 0x93, 0x9f, 0x11, 0x8b, 0x36, 0x5d, 0xfb, 0xa0, 0x1b, 0x81, 0xc2, 0x9c, 0xb1, 0xb7, 0xe7, - 0xe3, 0x3d, 0x76, 0x0f, 0x4a, 0x62, 0x45, 0x71, 0x3a, 0x9d, 0x93, 0xce, 0x46, 0xa8, 0x5a, 0xc4, - 0x3b, 0x4c, 0xcc, 0xc8, 0x86, 0x99, 0x98, 0x69, 0x28, 0xfb, 0x90, 0x89, 0xa1, 0x1e, 0x21, 0x7e, - 0x5d, 0x00, 0x86, 0xdc, 0xd4, 0x8f, 0x99, 0xc7, 0x76, 0xea, 0x3f, 0x4e, 0x67, 0xca, 0xa8, 0xd2, - 0x59, 0x66, 0xb8, 0x74, 0x86, 0x54, 0x28, 0x11, 0x1a, 0xeb, 0x8a, 0xab, 0x3d, 0xaf, 0x75, 0x8c, - 0xa9, 0x3f, 0xcb, 0x42, 0x2d, 0xf6, 0xd4, 0xff, 0xea, 0x30, 0x1f, 0x7b, 0x64, 0x76, 0x28, 0x8f, - 0x4c, 0xa6, 0x8b, 0xb1, 0x51, 0xa7, 0x8b, 0xf1, 0x91, 0xa7, 0x8b, 0x5c, 0x77, 0x70, 0xfd, 0x65, - 0x16, 0x4e, 0x75, 0xdf, 0x25, 0xff, 0xdf, 0xcf, 0x6c, 0x13, 0x8a, 0xb2, 0x5f, 0xcb, 0x33, 0x58, - 0xba, 0x63, 0x03, 0x01, 0xc1, 0x13, 0xd8, 0x7f, 0xe2, 0xe0, 0xfe, 0x9a, 0x81, 0xfc, 0x16, 0xbb, - 0x32, 0x10, 0xcf, 0x65, 0xb7, 0x59, 0x42, 0x37, 0x3c, 0xd9, 0xe6, 0xc8, 0x6b, 0xf2, 0x69, 0xa4, - 0x01, 0x60, 0x13, 0x8a, 0xd8, 0x0d, 0xfc, 0x03, 0x7d, 0x98, 0x3a, 0x1b, 0x38, 0x84, 0x10, 0x70, - 0x54, 0x49, 0xb1, 0x09, 0xf5, 0xde, 0x7e, 0x8f, 0xce, 0x19, 0xa5, 0xbc, 0x26, 0x4f, 0xf7, 0x74, - 0x7d, 0x56, 0x19, 0x9a, 0xba, 0x0e, 0xb5, 0x84, 0x87, 0xac, 0xbb, 0x16, 0x31, 0x8d, 0xc0, 0x3b, - 0xa4, 0x1a, 0xa9, 0xc1, 0x38, 0xa1, 0xcb, 0x6d, 0x71, 0x00, 0x79, 0x4d, 0x3c, 0xa8, 0x3f, 0xce, - 0x40, 0x9e, 0x5f, 0x96, 0x36, 0xbc, 0xce, 0x63, 0x52, 0x86, 0x3c, 0xa6, 0x28, 0x73, 0x64, 0x86, - 0xc9, 0x1c, 0x3d, 0x17, 0x33, 0x51, 0x95, 0x75, 0x5e, 0xcc, 0xae, 0x42, 0x76, 0x17, 0xa7, 0x0d, - 0x7b, 0x8c, 0xf4, 0xb0, 0x5a, 0xf6, 0xa3, 0x0c, 0x94, 0x43, 0x1b, 0x5f, 0xc1, 0x76, 0x60, 0xa0, - 0xd3, 0x70, 0x92, 0x50, 0xdd, 0xee, 0xb5, 0xf4, 0x7b, 0x80, 0xf0, 0x23, 0x6c, 0xb6, 0x79, 0x33, - 0x79, 0x48, 0x9b, 0x9f, 0x8c, 0x90, 0xa2, 0x8a, 0xe0, 0x2e, 0x54, 0x63, 0xf8, 0xa1, 0x82, 0x50, - 0x25, 0xc2, 0x11, 0x2f, 0x79, 0xd0, 0x1d, 0x88, 0x87, 0x7a, 0xae, 0x09, 0xc7, 0x41, 0x9e, 0x88, - 0x60, 0x44, 0x5d, 0xf7, 0x8b, 0x0c, 0xa0, 0xc4, 0xcb, 0xf2, 0xd0, 0xd8, 0xfa, 0xde, 0xb9, 0xbb, - 0x8f, 0x76, 0x0b, 0x26, 0x5a, 0x52, 0xf1, 0xba, 0xc5, 0x34, 0x2f, 0xcb, 0xe8, 0x97, 0x07, 0x05, - 0xed, 0x8e, 0xa3, 0xd2, 0xca, 0xad, 0x8e, 0x93, 0x5b, 0x83, 0x5c, 0xcb, 0x38, 0xf0, 0xda, 0x69, - 0xfb, 0x81, 0x92, 0xfa, 0xf9, 0x1b, 0xdd, 0x67, 0x0a, 0x9c, 0x5e, 0xdd, 0xc7, 0x6e, 0xb0, 0x6c, - 0x04, 0x66, 0x93, 0x5d, 0xa5, 0x56, 0x43, 0xbd, 0x0e, 0x76, 0xf4, 0x53, 0x2c, 0x08, 0xeb, 0x3b, - 0x5d, 0x9e, 0x8e, 0x36, 0xa1, 0x1c, 0x1d, 0xcc, 0x76, 0x7c, 0x89, 0x18, 0xa8, 0xc9, 0xd5, 0x24, - 0x81, 0xd6, 0x49, 0x8f, 0xbe, 0x06, 0xb9, 0x80, 0x1d, 0x26, 0xad, 0x8f, 0x2d, 0x64, 0x2f, 0x16, - 0x3b, 0x5e, 0xc6, 0xf6, 0x20, 0x85, 0xc7, 0xae, 0x49, 0x1a, 0xf5, 0x6f, 0x19, 0x38, 0x17, 0x8b, - 0x17, 0xdb, 0xc7, 0x70, 0x42, 0x5e, 0x80, 0x09, 0xe6, 0x97, 0xe4, 0x41, 0x9b, 0x58, 0xfc, 0x95, - 0x8b, 0xac, 0x0f, 0xcb, 0x84, 0x6e, 0xc4, 0x83, 0xcf, 0x68, 0xcd, 0xa7, 0xbb, 0x15, 0xf7, 0x69, - 0xcd, 0xf7, 0xa8, 0x7a, 0x7c, 0x48, 0x55, 0xaf, 0x45, 0xaa, 0xce, 0x71, 0x55, 0x2f, 0x0e, 0x42, - 0xea, 0xf5, 0xb5, 0x48, 0xe9, 0x1f, 0x00, 0x8a, 0x2b, 0xfc, 0x28, 0x6b, 0x5f, 0x85, 0x7c, 0xe8, - 0x23, 0xb2, 0xbe, 0x7a, 0xf1, 0x28, 0xee, 0xa5, 0x45, 0x54, 0xbd, 0xbe, 0x9c, 0xe9, 0xf5, 0x65, - 0xf5, 0x3b, 0x0a, 0x9c, 0xed, 0x77, 0xe2, 0xd1, 0x3e, 0x06, 0x1e, 0xf8, 0x06, 0x14, 0x42, 0x76, - 0xb4, 0x9e, 0x39, 0x5c, 0x0b, 0xbd, 0x72, 0x6a, 0x31, 0x80, 0xfa, 0x91, 0x02, 0xb3, 0x7c, 0x2f, - 0xdd, 0x35, 0xe7, 0x96, 0xd1, 0xa6, 0xd8, 0x1a, 0xbc, 0x95, 0xf3, 0x50, 0x12, 0xef, 0x1b, 0x92, - 0xef, 0x2c, 0xb4, 0xa2, 0x18, 0x13, 0x35, 0xc5, 0x22, 0x4c, 0x89, 0x0e, 0xa7, 0x43, 0x28, 0xe5, - 0x1f, 0x8d, 0xb5, 0x5d, 0x8b, 0xca, 0x3e, 0xfd, 0x24, 0x9f, 0xba, 0x21, 0x66, 0x98, 0xcd, 0x50, - 0xf4, 0x0a, 0xa0, 0x8e, 0x95, 0x89, 0x96, 0xbd, 0x56, 0x75, 0x12, 0x2b, 0x35, 0x23, 0xc0, 0xea, - 0xaf, 0x14, 0x40, 0x7c, 0xf7, 0x37, 0xf1, 0xc3, 0xa8, 0xb5, 0x47, 0x07, 0x6f, 0x7a, 0x1d, 0x60, - 0xa7, 0x7d, 0x20, 0x2e, 0xbd, 0xa1, 0x02, 0x2f, 0x0d, 0x54, 0x60, 0x47, 0x87, 0x4c, 0x2b, 0xec, - 0xb4, 0x0f, 0x24, 0x9f, 0x77, 0xa0, 0x48, 0xb1, 0x6d, 0x87, 0x58, 0xd9, 0x63, 0x63, 0x01, 0x23, - 0x17, 0x60, 0xea, 0xef, 0x15, 0xa8, 0x87, 0xb2, 0x74, 0x75, 0x57, 0x0e, 0x91, 0x68, 0xb3, 0x8f, - 0x44, 0xaf, 0x1d, 0xcd, 0x31, 0xfa, 0xcb, 0x75, 0xab, 0x9f, 0x5c, 0xc7, 0x47, 0x4c, 0x4a, 0xf7, - 0x01, 0xd4, 0xb8, 0x70, 0xd7, 0x0c, 0xd7, 0xc4, 0xf6, 0x11, 0xdb, 0xb0, 0x6b, 0x30, 0xce, 0xb7, - 0x20, 0x73, 0xdd, 0x31, 0x34, 0x2b, 0x6f, 0x3c, 0x82, 0x5c, 0xbd, 0x07, 0xa7, 0x38, 0xf3, 0xb8, - 0x0d, 0x77, 0xbb, 0x65, 0x89, 0x0f, 0x81, 0x72, 0x82, 0x99, 0x74, 0xf7, 0x97, 0x0e, 0xe3, 0x20, - 0xa8, 0x25, 0xba, 0xa4, 0x55, 0x7f, 0x92, 0x81, 0x19, 0x8e, 0xdf, 0xf5, 0xfe, 0x53, 0x32, 0xb9, - 0xde, 0xc5, 0xe4, 0x95, 0xa3, 0x29, 0xb2, 0x1f, 0x2b, 0x44, 0xe0, 0x54, 0x2b, 0x64, 0x12, 0x7f, - 0x96, 0x19, 0x35, 0xd5, 0x96, 0x06, 0x86, 0xab, 0xde, 0x97, 0xdf, 0x1c, 0x5d, 0xd1, 0xa6, 0x5a, - 0x7d, 0xde, 0x8b, 0x6b, 0x70, 0x32, 0xcc, 0x07, 0x59, 0x0e, 0x7e, 0xe5, 0x18, 0xe0, 0x32, 0x01, - 0x48, 0xfc, 0x10, 0x48, 0xfd, 0x93, 0x02, 0x73, 0x5c, 0x53, 0x7d, 0x3e, 0x83, 0x78, 0x0e, 0xda, - 0xda, 0x87, 0x19, 0xfe, 0xcd, 0xc1, 0x81, 0xbe, 0x2b, 0x38, 0x75, 0xa8, 0x4c, 0x48, 0xf5, 0xfa, - 0xe0, 0x5c, 0xd4, 0xf7, 0x6b, 0x0d, 0x29, 0xd6, 0x69, 0xdc, 0x7f, 0x5a, 0xfd, 0x7e, 0x06, 0xce, - 0xf7, 0x33, 0x08, 0xa9, 0x15, 0x29, 0xe9, 0x40, 0xd3, 0x4f, 0x68, 0x3f, 0x33, 0x94, 0xf6, 0x4f, - 0x44, 0xda, 0x47, 0x97, 0x60, 0x92, 0xd0, 0xae, 0x0f, 0xfb, 0x64, 0x59, 0x50, 0x21, 0xb4, 0xe3, - 0xd3, 0x3c, 0x74, 0x0b, 0x4a, 0xc9, 0x2f, 0x1e, 0x52, 0x96, 0x04, 0xc5, 0xdd, 0xf8, 0x3b, 0x07, - 0xf5, 0x07, 0x0a, 0x4c, 0x0b, 0x37, 0x8c, 0x32, 0x52, 0xf8, 0x92, 0x6d, 0x1e, 0x8a, 0xd4, 0x37, - 0x75, 0xc3, 0xb2, 0x7c, 0x4c, 0xa9, 0x54, 0x06, 0x50, 0xdf, 0x7c, 0x4b, 0x8c, 0x1c, 0x29, 0xaf, - 0xa2, 0x37, 0x20, 0x67, 0x38, 0xbc, 0x8b, 0x99, 0x3d, 0xda, 0x57, 0xc9, 0x72, 0xb9, 0xfa, 0x61, - 0x58, 0x61, 0xc6, 0x3b, 0xbb, 0x43, 0x82, 0xa6, 0xe5, 0x1b, 0x0f, 0x8f, 0x56, 0x9d, 0xcf, 0x43, - 0xd1, 0xa2, 0x41, 0xb4, 0x7f, 0xf9, 0x5d, 0x9f, 0x45, 0x83, 0x70, 0xff, 0xa9, 0xb7, 0xf6, 0xf3, - 0xd0, 0x63, 0xe2, 0xad, 0xc9, 0xf7, 0x7c, 0xdb, 0xbe, 0xe1, 0xd2, 0x5d, 0xec, 0xb3, 0x63, 0x65, - 0xca, 0xeb, 0xf7, 0xde, 0xae, 0x42, 0x7d, 0xb3, 0x91, 0xdc, 0xe8, 0x25, 0x98, 0x64, 0x1b, 0xed, - 0xd5, 0x65, 0x41, 0xab, 0x58, 0x34, 0x68, 0x8c, 0x44, 0x9d, 0x0f, 0x61, 0xb2, 0xf7, 0x88, 0x8f, - 0xa4, 0xc7, 0x37, 0xe1, 0xa4, 0x25, 0xd6, 0x4b, 0xab, 0x7f, 0x61, 0xb0, 0xf7, 0xf3, 0xa5, 0x5a, - 0x48, 0xa3, 0xb6, 0xa0, 0x2c, 0xc7, 0xa4, 0x8b, 0xd5, 0x60, 0x5c, 0x7c, 0x17, 0x20, 0xd4, 0x21, - 0x1e, 0xd0, 0x3a, 0xe4, 0x25, 0x45, 0x98, 0x2d, 0x5f, 0x3d, 0x5a, 0x01, 0x15, 0x32, 0x8c, 0xc8, - 0x55, 0x27, 0x79, 0x35, 0xe9, 0xe4, 0xad, 0x41, 0x45, 0x2e, 0xd3, 0xdb, 0x7c, 0x84, 0xd9, 0x75, - 0xf6, 0xb0, 0x2b, 0x5b, 0x07, 0x86, 0x36, 0x61, 0x25, 0x1f, 0xa9, 0xfa, 0x1b, 0x05, 0x66, 0xfb, - 0x36, 0x07, 0x45, 0x5a, 0x45, 0xef, 0x42, 0x49, 0x86, 0x14, 0x91, 0x37, 0x45, 0x08, 0xbd, 0x7c, - 0x9c, 0x10, 0x1a, 0xa7, 0x4f, 0x45, 0x2b, 0x3a, 0x89, 0xf6, 0xe3, 0x1d, 0xa8, 0x98, 0x9c, 0xcb, - 0xb0, 0xb7, 0xf9, 0x09, 0x01, 0x13, 0xb5, 0xdb, 0xa3, 0xf4, 0x29, 0x84, 0x38, 0xd6, 0x9b, 0xa5, - 0x17, 0x81, 0x5f, 0x68, 0x1c, 0x22, 0x89, 0xe5, 0x25, 0xa8, 0x73, 0x10, 0xdd, 0x81, 0x62, 0xe2, - 0x4d, 0x87, 0x34, 0xe7, 0x63, 0xd7, 0x33, 0x52, 0x29, 0x60, 0xc7, 0x6d, 0x74, 0x07, 0xa6, 0x92, - 0xfa, 0xd6, 0x85, 0x64, 0x3c, 0x58, 0x16, 0xaf, 0xbc, 0x71, 0x6c, 0xb5, 0x8b, 0xed, 0x4a, 0x3e, - 0x93, 0x4e, 0xf7, 0xc4, 0x25, 0x13, 0x4a, 0xc9, 0x6f, 0x2e, 0x50, 0x05, 0x8a, 0xb7, 0x5d, 0xda, - 0xc2, 0x26, 0xd9, 0x25, 0xd8, 0xaa, 0x9e, 0x40, 0x00, 0xb9, 0xb7, 0x38, 0xc3, 0xaa, 0xc2, 0x7e, - 0x8b, 0x1a, 0xbe, 0x9a, 0x41, 0x65, 0x28, 0x34, 0xda, 0xb4, 0x85, 0x5d, 0x0b, 0x5b, 0xd5, 0x2c, - 0x9a, 0x00, 0x58, 0xc1, 0x8e, 0x67, 0x13, 0xda, 0xc4, 0x56, 0x75, 0x0c, 0x15, 0xe1, 0x24, 0xcf, - 0x74, 0xd8, 0xaa, 0x8e, 0x5f, 0xfa, 0x38, 0xfc, 0x20, 0x80, 0x5f, 0xb8, 0x16, 0xa0, 0x78, 0xfb, - 0x66, 0x63, 0x6b, 0xf5, 0xda, 0xfa, 0xda, 0xfa, 0xea, 0x4a, 0xf5, 0xc4, 0x4c, 0xe5, 0xf1, 0x93, - 0x85, 0xe4, 0x10, 0xaa, 0x42, 0x76, 0xf9, 0xf6, 0xdd, 0xaa, 0x32, 0x73, 0xf2, 0xf1, 0x93, 0x05, - 0xf6, 0x13, 0x21, 0x18, 0x6b, 0xac, 0x6e, 0x6c, 0x54, 0x33, 0x33, 0xf9, 0xc7, 0x4f, 0x16, 0xf8, - 0x6f, 0x34, 0x03, 0xf9, 0xc6, 0xf6, 0xe6, 0x96, 0xce, 0x96, 0x66, 0x67, 0x4a, 0x8f, 0x9f, 0x2c, - 0x44, 0xcf, 0xe8, 0x2c, 0x14, 0xf8, 0x6f, 0x4e, 0x34, 0x36, 0x53, 0x7e, 0xfc, 0x64, 0x21, 0x1e, - 0x60, 0x94, 0xdb, 0x6f, 0xbd, 0xb3, 0xca, 0x29, 0xc7, 0x05, 0x65, 0xf8, 0xcc, 0x28, 0xf9, 0x6f, - 0x4e, 0x99, 0x13, 0x94, 0xd1, 0xc0, 0xa5, 0x6f, 0x41, 0xb9, 0xe3, 0x32, 0x89, 0xce, 0x42, 0x3d, - 0xa1, 0xaf, 0x8e, 0x39, 0xa1, 0x3c, 0xa1, 0xdd, 0xaa, 0xc2, 0x14, 0xc6, 0x0f, 0x7e, 0x8d, 0xd8, - 0x76, 0x35, 0x83, 0x66, 0x60, 0x9a, 0x3f, 0xde, 0x60, 0x6e, 0xae, 0x61, 0xfe, 0x3f, 0x2b, 0x5c, - 0x47, 0xd5, 0x2c, 0x9a, 0x06, 0x14, 0xcf, 0xdd, 0xc4, 0x0f, 0xc5, 0xf8, 0xd8, 0x72, 0xf3, 0x93, - 0xa7, 0x73, 0xca, 0xa7, 0x4f, 0xe7, 0x94, 0x3f, 0x3e, 0x9d, 0x53, 0xbe, 0xf7, 0xc5, 0xdc, 0x89, - 0x4f, 0xbf, 0x98, 0x3b, 0xf1, 0xdb, 0x2f, 0xe6, 0x4e, 0xbc, 0x7b, 0x33, 0xe1, 0x28, 0xeb, 0xa1, - 0x89, 0x6c, 0x18, 0x3b, 0x74, 0x29, 0x32, 0x98, 0x57, 0x4d, 0xcf, 0xc7, 0xc9, 0xc7, 0xa6, 0x41, - 0xdc, 0x25, 0xc7, 0xb3, 0xda, 0x36, 0xa6, 0xf1, 0x3f, 0x2a, 0x71, 0xa7, 0xda, 0xc9, 0xf1, 0xff, - 0x12, 0x7a, 0xfd, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x3a, 0x0f, 0x57, 0xac, 0xcb, 0x34, 0x00, - 0x00, + // 3327 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x5b, 0xcb, 0x6f, 0x1c, 0x47, + 0x7a, 0x57, 0xcf, 0x90, 0xd4, 0xcc, 0x37, 0x1c, 0xce, 0xb0, 0x48, 0x91, 0x23, 0x52, 0x22, 0xa9, + 0xb6, 0x25, 0xc8, 0x82, 0x4d, 0x5a, 0x72, 0x00, 0x27, 0x41, 0x0c, 0xc8, 0x14, 0x49, 0x98, 0x32, + 0x29, 0x52, 0x3d, 0x54, 0x04, 0x39, 0x50, 0xda, 0xc5, 0xee, 0x22, 0xa7, 0xac, 0x7e, 0x8c, 0xba, + 0x7a, 0xf8, 0xb0, 0x73, 0xca, 0x2d, 0xba, 0x24, 0x40, 0x0e, 0x71, 0x0e, 0x02, 0x82, 0x5c, 0x12, + 0xe4, 0x94, 0x00, 0x41, 0x0e, 0xf1, 0x1f, 0x60, 0xe7, 0x14, 0x23, 0xa7, 0x60, 0xd7, 0xeb, 0x5d, + 0xc8, 0x0b, 0xec, 0x5e, 0x77, 0xf7, 0xb4, 0x58, 0x2c, 0xb0, 0xa8, 0x47, 0x3f, 0xe6, 0xa1, 0x21, + 0xd9, 0xa4, 0xb0, 0x8f, 0x13, 0xd9, 0x55, 0xf5, 0xfd, 0xbe, 0xfa, 0xbe, 0xfa, 0x5e, 0xf5, 0x75, + 0x0f, 0xbc, 0x41, 0xbd, 0x4f, 0x88, 0x15, 0xd2, 0x3d, 0xb2, 0x40, 0x0e, 0xac, 0x06, 0xf6, 0x76, + 0xc9, 0xc2, 0xde, 0xcd, 0x6d, 0x12, 0xe2, 0x9b, 0xf1, 0xc0, 0x7c, 0x33, 0xf0, 0x43, 0x1f, 0x4d, + 0xc5, 0x4b, 0xe7, 0xe3, 0x19, 0xb5, 0x74, 0x6a, 0x7c, 0xd7, 0xdf, 0xf5, 0xc5, 0xb2, 0x05, 0xfe, + 0x9f, 0xa4, 0x98, 0x9a, 0xb1, 0x7c, 0xe6, 0xfa, 0x6c, 0x61, 0x1b, 0xb3, 0x04, 0xd5, 0xf2, 0xa9, + 0xa7, 0xe6, 0xaf, 0x26, 0xcc, 0xfd, 0x00, 0x5b, 0x4e, 0xb2, 0x48, 0x3e, 0xca, 0x65, 0xfa, 0x3f, + 0x96, 0x60, 0x68, 0x13, 0x07, 0xd8, 0x65, 0x88, 0xc0, 0x2c, 0x6b, 0xfa, 0xa1, 0xe9, 0xe2, 0xe0, + 0x09, 0x09, 0x4d, 0xea, 0xb1, 0x10, 0x7b, 0xa1, 0xe9, 0x50, 0x16, 0x52, 0x6f, 0xd7, 0xdc, 0x21, + 0xa4, 0xa6, 0xcd, 0x69, 0xd7, 0x4b, 0xb7, 0x2e, 0xce, 0x4b, 0xde, 0xf3, 0x9c, 0x77, 0xb4, 0xcd, + 0xf9, 0x3b, 0x3e, 0xf5, 0x16, 0x07, 0xbe, 0xfa, 0x76, 0xf6, 0x9c, 0x31, 0xcd, 0x71, 0xd6, 0x05, + 0xcc, 0xaa, 0x44, 0x59, 0x93, 0x20, 0x2b, 0x84, 0xa0, 0xa7, 0x70, 0xd5, 0x26, 0x01, 0xdd, 0xc3, + 0x7c, 0x6f, 0xfd, 0x98, 0xe5, 0x8e, 0xc7, 0xec, 0x4a, 0x82, 0xf6, 0x32, 0x96, 0x0e, 0x4c, 0xdb, + 0x64, 0x07, 0xb7, 0x9c, 0xd0, 0x54, 0x12, 0x3e, 0x21, 0x01, 0xe7, 0x61, 0x06, 0x38, 0x24, 0xb5, + 0xfc, 0x9c, 0x76, 0xbd, 0xb8, 0x38, 0xcf, 0xd1, 0xbe, 0xf7, 0xed, 0xec, 0xb5, 0x5d, 0x1a, 0x36, + 0x5a, 0xdb, 0xf3, 0x96, 0xef, 0x2e, 0x28, 0x1d, 0xcb, 0x3f, 0x6f, 0x31, 0xfb, 0xc9, 0x42, 0x78, + 0xd8, 0x24, 0x6c, 0x7e, 0x89, 0x58, 0xc6, 0xa4, 0x82, 0xac, 0x0b, 0x59, 0x9f, 0x90, 0x60, 0x85, + 0x10, 0x03, 0x87, 0xdd, 0xdc, 0xc2, 0x76, 0x6e, 0x03, 0xa7, 0xe6, 0xb6, 0x95, 0xe6, 0x76, 0x00, + 0x57, 0x22, 0x6e, 0x6d, 0x6a, 0x6d, 0xe3, 0x39, 0x98, 0x89, 0xe7, 0x65, 0x05, 0xbc, 0x94, 0x52, + 0xf0, 0x91, 0x9c, 0x3b, 0xa4, 0x1d, 0x3a, 0x23, 0xce, 0x6d, 0x32, 0xfb, 0x70, 0x29, 0xe2, 0x4c, + 0x3d, 0x1a, 0x52, 0xec, 0x70, 0x3b, 0xda, 0xa5, 0x1e, 0xe7, 0x49, 0xfd, 0xda, 0xf9, 0x4c, 0x4c, + 0x2f, 0x2a, 0xcc, 0x55, 0x09, 0xb9, 0x2e, 0x10, 0x0d, 0x0e, 0x88, 0xf6, 0x61, 0x2e, 0x62, 0xe8, + 0x62, 0xea, 0x85, 0xc4, 0xc3, 0x9e, 0x45, 0xda, 0x99, 0x16, 0x4e, 0x25, 0xe9, 0x7a, 0x02, 0x9b, + 0x66, 0xfc, 0xc7, 0x50, 0x8b, 0x18, 0xef, 0xb4, 0x3c, 0x9b, 0xbb, 0x06, 0x5f, 0x17, 0xec, 0x61, + 0xa7, 0x56, 0x9c, 0xd3, 0xae, 0xe7, 0x8d, 0x09, 0x35, 0xbf, 0x22, 0xa7, 0x57, 0xd5, 0x2c, 0x7a, + 0x03, 0xaa, 0x11, 0x85, 0xdb, 0x72, 0x42, 0xda, 0x74, 0x48, 0x0d, 0x04, 0x45, 0x45, 0x8d, 0xaf, + 0xab, 0x61, 0x64, 0xc1, 0x44, 0x40, 0x1c, 0x7c, 0xa8, 0xce, 0x8d, 0x35, 0x70, 0xa0, 0x4e, 0xaf, + 0x94, 0x49, 0xa6, 0x31, 0x85, 0xb6, 0x42, 0x48, 0x9d, 0x63, 0x89, 0x33, 0x0b, 0x61, 0x36, 0x92, + 0xa4, 0xe1, 0xb7, 0x02, 0xe7, 0x30, 0x16, 0x88, 0x73, 0x32, 0x2d, 0xdc, 0xac, 0x0d, 0x67, 0xe2, + 0x16, 0x39, 0xdb, 0x07, 0x02, 0x55, 0xa9, 0x81, 0xb3, 0xbc, 0x83, 0x9b, 0x69, 0x4b, 0x51, 0x5c, + 0x85, 0xfa, 0x08, 0x0b, 0xa5, 0x80, 0xe5, 0x53, 0x59, 0x8a, 0x64, 0xb9, 0xaa, 0x10, 0x85, 0x98, + 0x4b, 0x30, 0xeb, 0xe2, 0x83, 0xb4, 0x43, 0xf8, 0x81, 0x4d, 0x02, 0x93, 0x51, 0x9b, 0x98, 0x96, + 0xdf, 0xf2, 0xc2, 0xda, 0xc8, 0x9c, 0x76, 0xbd, 0x6c, 0x4c, 0xbb, 0xf8, 0x20, 0x31, 0xef, 0x0d, + 0xbe, 0xa8, 0x4e, 0x6d, 0x72, 0x87, 0x2f, 0xf9, 0xd3, 0x81, 0x9f, 0xfe, 0xd3, 0xac, 0xa6, 0xff, + 0x6b, 0x01, 0xaa, 0x4b, 0x1d, 0xc1, 0x0d, 0x4d, 0xc0, 0x50, 0x48, 0xad, 0x27, 0x24, 0x10, 0xc1, + 0xb8, 0x68, 0xa8, 0x27, 0x34, 0x0b, 0x25, 0x19, 0xd8, 0x4d, 0x1e, 0x28, 0x45, 0xf0, 0x2c, 0x1a, + 0x20, 0x87, 0x16, 0x31, 0x23, 0xe8, 0x0a, 0x0c, 0xab, 0x05, 0x4f, 0x5b, 0x7e, 0x14, 0xf5, 0x0c, + 0x45, 0x74, 0x9f, 0x0f, 0xa1, 0xe5, 0x18, 0x83, 0xcb, 0x2a, 0x22, 0xd5, 0xc8, 0xad, 0xd7, 0xe7, + 0x93, 0xdc, 0xa4, 0x52, 0x47, 0x14, 0x85, 0x37, 0xc4, 0xe3, 0xd6, 0x61, 0x93, 0x44, 0x9c, 0xf8, + 0xff, 0x68, 0x1e, 0xc6, 0x14, 0x0c, 0xb3, 0xb0, 0x43, 0xcc, 0x1d, 0x6c, 0x85, 0x7e, 0x20, 0x82, + 0x50, 0xd9, 0x18, 0x95, 0x53, 0x75, 0x3e, 0xb3, 0x22, 0x26, 0xf8, 0xd6, 0xc5, 0x96, 0x4c, 0x9b, + 0x78, 0xbe, 0x2b, 0x43, 0x86, 0x01, 0x62, 0x68, 0x89, 0x8f, 0xa0, 0x69, 0x28, 0x46, 0x79, 0xc2, + 0x96, 0xce, 0x6d, 0x14, 0xe4, 0xc0, 0xaa, 0x8d, 0x3e, 0x86, 0xf1, 0x9e, 0x41, 0x20, 0x9b, 0x3f, + 0x22, 0xda, 0xed, 0xfd, 0x0d, 0xa8, 0xbd, 0xd4, 0xeb, 0x8b, 0x99, 0xb8, 0x4c, 0xb8, 0xbd, 0xdd, + 0x7d, 0x0b, 0x46, 0x3a, 0x22, 0x37, 0x64, 0xc2, 0x1f, 0x76, 0xd3, 0xe1, 0x72, 0x0b, 0x46, 0x3a, + 0xa2, 0x72, 0x36, 0xbf, 0x1e, 0x0e, 0xd3, 0xa8, 0x2f, 0x8f, 0x1a, 0xc3, 0x67, 0x17, 0x35, 0xe6, + 0xa0, 0x44, 0xd9, 0x26, 0x09, 0x9a, 0x24, 0x6c, 0x61, 0x47, 0xb8, 0x6b, 0xc1, 0x48, 0x0f, 0xa1, + 0xdb, 0x30, 0xc4, 0x42, 0x1c, 0xb6, 0x98, 0xf0, 0xab, 0x91, 0x5b, 0xd7, 0xe7, 0x5f, 0x5e, 0x4a, + 0xcd, 0x4b, 0x1f, 0xaa, 0x8b, 0xf5, 0x86, 0xa2, 0x43, 0x8f, 0x61, 0xcc, 0xa5, 0x9e, 0xd9, 0x0c, + 0xa8, 0x45, 0x4c, 0xee, 0x4d, 0x26, 0xa3, 0x9f, 0x92, 0x5a, 0x25, 0x93, 0x14, 0x55, 0x97, 0x7a, + 0x9b, 0x1c, 0x69, 0x8b, 0x5a, 0x4f, 0xea, 0xf4, 0x53, 0xa1, 0x27, 0x0e, 0xff, 0xb4, 0x85, 0xbd, + 0x90, 0x86, 0x87, 0x29, 0x0e, 0xd5, 0x6c, 0x7a, 0x72, 0xa9, 0x77, 0x5f, 0x81, 0x45, 0x4c, 0xf4, + 0x5f, 0xe5, 0x60, 0x72, 0xf9, 0xa0, 0x49, 0x83, 0xc3, 0x95, 0x56, 0xd8, 0x0a, 0x08, 0x8b, 0x4a, + 0xa1, 0x1d, 0xbf, 0xdd, 0x7b, 0xb4, 0x0e, 0xef, 0xb9, 0x09, 0xe3, 0x84, 0xd3, 0x71, 0xf3, 0xf3, + 0xcc, 0x90, 0xba, 0x84, 0x85, 0xd8, 0x6d, 0x8a, 0xf8, 0x91, 0x37, 0xc6, 0x92, 0xb9, 0xad, 0x68, + 0x0a, 0xbd, 0x0d, 0xe3, 0xe1, 0x3e, 0x6e, 0x9a, 0x2c, 0xc4, 0x41, 0x98, 0x22, 0xc9, 0x0b, 0x12, + 0xc4, 0xe7, 0xea, 0x7c, 0x2a, 0xa1, 0xf8, 0x6b, 0x0d, 0xae, 0xa5, 0xb9, 0x24, 0xd4, 0x52, 0xe9, + 0x56, 0xcb, 0x6d, 0x39, 0x22, 0xc8, 0x65, 0xac, 0x8e, 0xf4, 0xd4, 0x3e, 0x23, 0xf6, 0xe2, 0x14, + 0xee, 0xc4, 0xc8, 0xe8, 0x11, 0x54, 0x19, 0x09, 0x43, 0x87, 0xb8, 0xc4, 0x53, 0x8c, 0x33, 0xd6, + 0x45, 0x95, 0x04, 0x47, 0x30, 0xd1, 0xbf, 0xc9, 0xc1, 0x58, 0x6c, 0x91, 0xc7, 0xd5, 0x3c, 0x81, + 0xc9, 0x97, 0x25, 0xc2, 0x5c, 0xa6, 0x6d, 0x8d, 0x37, 0x7a, 0x65, 0xc0, 0x8f, 0x61, 0xbc, 0x67, + 0xe6, 0xcb, 0x56, 0xf4, 0xa2, 0x46, 0x77, 0xca, 0xfb, 0x23, 0x98, 0xf0, 0xc8, 0x41, 0x52, 0xa0, + 0x24, 0x16, 0x31, 0x20, 0x2c, 0x62, 0x9c, 0xcf, 0xaa, 0x5d, 0x25, 0x36, 0x91, 0xaa, 0x4f, 0xe2, + 0x8a, 0x66, 0xb0, 0xad, 0x3e, 0x89, 0x4a, 0x19, 0xfd, 0x97, 0x1a, 0x4c, 0x74, 0xa8, 0x57, 0xc1, + 0xa1, 0xc7, 0x80, 0x12, 0xe3, 0x89, 0x76, 0x20, 0x55, 0x7d, 0x62, 0xd9, 0x46, 0x13, 0xa4, 0x08, + 0xfe, 0x11, 0x54, 0x53, 0xf0, 0xd2, 0x66, 0xb2, 0x1d, 0x4e, 0x25, 0xc1, 0x11, 0x36, 0x83, 0xae, + 0xc2, 0x88, 0x83, 0x59, 0xb7, 0xff, 0x94, 0xf9, 0x68, 0xac, 0x26, 0xfd, 0x17, 0x1a, 0xcc, 0x74, + 0xd6, 0x00, 0xf5, 0xd8, 0xfc, 0x8e, 0xb6, 0xb2, 0x5e, 0x56, 0x9f, 0x3b, 0x13, 0xab, 0x17, 0xd0, + 0xdc, 0xd1, 0xf8, 0x11, 0xda, 0x64, 0x87, 0x5a, 0x34, 0xcc, 0x68, 0x55, 0x95, 0x08, 0x67, 0x49, + 0xc2, 0xe8, 0xef, 0xc1, 0xf8, 0xbd, 0x5e, 0x46, 0x73, 0x15, 0x46, 0x84, 0xa9, 0x25, 0x4a, 0xd3, + 0xa4, 0xd2, 0xf8, 0x68, 0xa2, 0xb4, 0xcf, 0x07, 0x01, 0xea, 0xf1, 0x15, 0xf4, 0xa5, 0x25, 0xd3, + 0x65, 0x00, 0x5e, 0x2b, 0xa9, 0xb2, 0x43, 0x56, 0x4c, 0x45, 0x3e, 0x22, 0xab, 0x8e, 0x8e, 0xb2, + 0x24, 0xdf, 0x55, 0x96, 0x74, 0x67, 0xeb, 0x81, 0x57, 0x92, 0xad, 0x07, 0x5f, 0x69, 0xb6, 0x1e, + 0x3a, 0xbb, 0x6c, 0xdd, 0xb7, 0x4e, 0x4b, 0x12, 0x75, 0xe1, 0x6c, 0x13, 0x75, 0xf1, 0x95, 0x27, + 0x6a, 0x38, 0xbb, 0x44, 0xfd, 0x85, 0x06, 0xe7, 0x97, 0x48, 0xd3, 0x67, 0x34, 0x44, 0x7f, 0x01, + 0xa3, 0x78, 0x0f, 0x53, 0x07, 0x6f, 0x8b, 0xaa, 0xdd, 0xe1, 0xd5, 0x60, 0xc6, 0xd8, 0x55, 0x8d, + 0x81, 0x16, 0x25, 0x0e, 0xaa, 0x43, 0x39, 0xf4, 0x43, 0xec, 0xc4, 0xc0, 0xb9, 0x8c, 0x56, 0xc4, + 0x41, 0x14, 0xa8, 0xfe, 0x26, 0x8c, 0xd7, 0x5b, 0xdb, 0xd8, 0x12, 0x17, 0x99, 0xad, 0x00, 0xdb, + 0xe4, 0x9e, 0xcf, 0x99, 0x8d, 0xc3, 0xa0, 0xe7, 0x47, 0xbb, 0x2f, 0x1b, 0xf2, 0x41, 0xff, 0x89, + 0x06, 0x45, 0x71, 0xb1, 0x11, 0x61, 0xea, 0x35, 0x28, 0xb3, 0x98, 0x36, 0x09, 0x55, 0xc3, 0xc9, + 0xe0, 0xaa, 0xcd, 0x17, 0x09, 0xb3, 0x27, 0x16, 0x6d, 0x52, 0xe2, 0x85, 0xca, 0x2b, 0x87, 0x77, + 0x08, 0x31, 0xa2, 0x31, 0xb4, 0x04, 0x83, 0x32, 0x90, 0x65, 0x8b, 0x36, 0x92, 0x18, 0xdd, 0x85, + 0x42, 0x74, 0xd4, 0x19, 0xfd, 0x36, 0xa6, 0xd7, 0xff, 0x36, 0x07, 0x45, 0x1e, 0x70, 0x84, 0xb4, + 0xfd, 0x03, 0xf2, 0x5d, 0x00, 0x79, 0x23, 0xa4, 0xde, 0x8e, 0xaf, 0x7a, 0x5c, 0x57, 0xfb, 0xb9, + 0x42, 0xac, 0x41, 0xd5, 0xef, 0x2a, 0xfa, 0xb1, 0x4a, 0x97, 0x22, 0x2c, 0x71, 0x5d, 0xcb, 0x0b, + 0xb7, 0x3a, 0x1a, 0x4b, 0xdc, 0xd7, 0x24, 0x8a, 0xb8, 0xae, 0x71, 0x4b, 0x09, 0xe8, 0xee, 0x2e, + 0x09, 0x54, 0x7e, 0x48, 0xb4, 0xa1, 0x9d, 0xc8, 0x52, 0x24, 0x88, 0x2c, 0x89, 0x5e, 0xe4, 0x60, + 0x84, 0x6b, 0x64, 0x8d, 0xba, 0x54, 0xa9, 0xa5, 0x5d, 0x72, 0xed, 0x0c, 0x25, 0xcf, 0x65, 0x94, + 0xfc, 0x2e, 0x14, 0x76, 0xa8, 0x23, 0xdc, 0x26, 0xa3, 0x2d, 0xc5, 0xf4, 0xaf, 0x44, 0x8b, 0x3c, + 0x43, 0x49, 0x31, 0x1b, 0x98, 0x35, 0x44, 0x1e, 0x18, 0x56, 0xfb, 0xff, 0x00, 0xb3, 0x86, 0xfe, + 0xbf, 0x1a, 0x54, 0x92, 0x3c, 0x77, 0xf6, 0x5a, 0xbe, 0x0f, 0xc3, 0x2a, 0x7a, 0x98, 0x0d, 0xdf, + 0xb1, 0x33, 0x86, 0x90, 0x92, 0xc2, 0xf8, 0xc0, 0x77, 0xec, 0x0e, 0x89, 0xf2, 0x9d, 0x12, 0xfd, + 0x20, 0x07, 0x95, 0x8e, 0xae, 0xc8, 0xef, 0x9b, 0x3b, 0xad, 0xc0, 0x90, 0xec, 0x10, 0x64, 0x8c, + 0x2a, 0x8a, 0xba, 0xdb, 0xa0, 0x06, 0xcf, 0xc0, 0x2d, 0x7f, 0x9d, 0x83, 0xe9, 0x24, 0x82, 0x8b, + 0xfd, 0x6f, 0xfb, 0xfe, 0x93, 0x75, 0x12, 0x62, 0x1b, 0x87, 0x18, 0xfd, 0x09, 0x5c, 0xdc, 0xc3, + 0x1e, 0xb7, 0x69, 0xd3, 0xe1, 0x9e, 0xab, 0xba, 0x57, 0xb2, 0x71, 0x25, 0x83, 0xfb, 0x84, 0x5a, + 0x90, 0x78, 0xb6, 0xe8, 0x59, 0xa1, 0xdb, 0x70, 0x39, 0x20, 0x76, 0xcb, 0x22, 0xa6, 0xef, 0x39, + 0x87, 0x3d, 0xc8, 0x73, 0x82, 0xfc, 0xa2, 0x5c, 0xb4, 0xe1, 0x39, 0x87, 0x9d, 0x08, 0x0c, 0x66, + 0xf0, 0xee, 0x6e, 0x40, 0x76, 0xf9, 0x3d, 0x28, 0x8d, 0x15, 0xc7, 0xe9, 0x6c, 0x4e, 0x3a, 0x1d, + 0xa3, 0x1a, 0x31, 0xef, 0x28, 0x31, 0x23, 0x07, 0xa6, 0x12, 0xa6, 0x91, 0xec, 0xa7, 0x4c, 0x0c, + 0xb5, 0x18, 0xf1, 0xcf, 0x25, 0x60, 0xc4, 0x4d, 0xff, 0x92, 0x7b, 0x6c, 0xbb, 0xfe, 0x93, 0x74, + 0xa6, 0x9d, 0x55, 0x3a, 0xcb, 0x9d, 0x2e, 0x9d, 0x21, 0x1d, 0x86, 0x29, 0x4b, 0x74, 0x25, 0xd4, + 0x5e, 0x30, 0xda, 0xc6, 0xf4, 0x7f, 0xcf, 0xc3, 0x78, 0xe2, 0xa9, 0xbf, 0xd3, 0x61, 0x3e, 0xf1, + 0xc8, 0xfc, 0xa9, 0x3c, 0x32, 0x9d, 0x2e, 0x06, 0xce, 0x3a, 0x5d, 0x0c, 0x9e, 0x79, 0xba, 0x18, + 0xea, 0x0c, 0xae, 0xff, 0x95, 0x87, 0x0b, 0x9d, 0x77, 0xc9, 0x3f, 0xf4, 0x33, 0xdb, 0x80, 0x92, + 0xea, 0xd7, 0x8a, 0x0c, 0x96, 0xed, 0xd8, 0x40, 0x42, 0x88, 0x04, 0xf6, 0xdb, 0x38, 0xb8, 0x9f, + 0xe5, 0xa0, 0xb0, 0xc9, 0xaf, 0x0c, 0xd4, 0xf7, 0xf8, 0x6d, 0x96, 0xb2, 0x35, 0x5f, 0xb5, 0x39, + 0x0a, 0x86, 0x7a, 0x3a, 0xd3, 0x00, 0xb0, 0x01, 0x25, 0xe2, 0x85, 0xc1, 0xa1, 0x79, 0x9a, 0x3a, + 0x1b, 0x04, 0x84, 0x14, 0xf0, 0xac, 0x92, 0x62, 0x03, 0x6a, 0xdd, 0xfd, 0x1e, 0x53, 0x30, 0xca, + 0x78, 0x4d, 0x9e, 0xe8, 0xea, 0xfa, 0x2c, 0x73, 0x34, 0x7d, 0x15, 0xc6, 0x53, 0x1e, 0xb2, 0xea, + 0xd9, 0xd4, 0xc2, 0xa1, 0x7f, 0x44, 0x35, 0x32, 0x0e, 0x83, 0x94, 0x2d, 0xb6, 0xe4, 0x01, 0x14, + 0x0c, 0xf9, 0xa0, 0xff, 0x73, 0x0e, 0x0a, 0xe2, 0xb2, 0xb4, 0xe6, 0xb7, 0x1f, 0x93, 0x76, 0xca, + 0x63, 0x8a, 0x33, 0x47, 0xee, 0x34, 0x99, 0xa3, 0xeb, 0x62, 0x26, 0xab, 0xb2, 0xf6, 0x8b, 0xd9, + 0x6d, 0xc8, 0xef, 0x90, 0xac, 0x61, 0x8f, 0x93, 0x1e, 0x55, 0xcb, 0x7e, 0x91, 0x83, 0x72, 0x64, + 0xe3, 0x4b, 0xc4, 0x09, 0x31, 0x9a, 0x84, 0xf3, 0x94, 0x99, 0x4e, 0xb7, 0xa5, 0x3f, 0x06, 0x44, + 0x0e, 0x88, 0xd5, 0x12, 0xcd, 0xe4, 0x53, 0xda, 0xfc, 0x68, 0x8c, 0x14, 0x57, 0x04, 0x8f, 0xa0, + 0x9a, 0xc0, 0x9f, 0x2a, 0x08, 0x55, 0x62, 0x1c, 0xf9, 0x92, 0x07, 0x3d, 0x84, 0x64, 0xa8, 0xeb, + 0x9a, 0x70, 0x12, 0xe4, 0x91, 0x18, 0x46, 0xd6, 0x75, 0xff, 0x99, 0x03, 0x94, 0x7a, 0x59, 0x1e, + 0x19, 0x5b, 0xcf, 0x3b, 0x77, 0xe7, 0xd1, 0x6e, 0xc2, 0x48, 0x53, 0x29, 0xde, 0xb4, 0xb9, 0xe6, + 0x55, 0x19, 0xfd, 0x46, 0xbf, 0xa0, 0xdd, 0x76, 0x54, 0x46, 0xb9, 0xd9, 0x76, 0x72, 0x2b, 0x30, + 0xd4, 0xc4, 0x87, 0x7e, 0x2b, 0x6b, 0x3f, 0x50, 0x51, 0xbf, 0x7a, 0xa3, 0xfb, 0x46, 0x83, 0xc9, + 0xe5, 0x3d, 0xe2, 0x85, 0x8b, 0x38, 0xb4, 0x1a, 0xfc, 0x2a, 0xb5, 0x1c, 0xe9, 0xb5, 0xbf, 0xa3, + 0x5f, 0xe0, 0x41, 0xd8, 0xdc, 0xee, 0xf0, 0x74, 0xb4, 0x01, 0xe5, 0xf8, 0x60, 0xb6, 0x92, 0x4b, + 0x44, 0x5f, 0x4d, 0x2e, 0xa7, 0x09, 0x8c, 0x76, 0x7a, 0xf4, 0x67, 0x30, 0x14, 0xf2, 0xc3, 0x64, + 0xb5, 0x81, 0xb9, 0xfc, 0xf5, 0x52, 0xdb, 0xcb, 0xd8, 0x2e, 0xa4, 0xe8, 0xd8, 0x0d, 0x45, 0xa3, + 0xff, 0x3c, 0x07, 0x97, 0x13, 0xf1, 0x12, 0xfb, 0x38, 0x9d, 0x90, 0x57, 0x61, 0x84, 0xfb, 0x25, + 0x7d, 0xda, 0xa2, 0xb6, 0x78, 0xe5, 0xa2, 0xea, 0xc3, 0x32, 0x65, 0x6b, 0xc9, 0xe0, 0x4b, 0x5a, + 0xf3, 0xd9, 0x6e, 0xc5, 0x3d, 0x5a, 0xf3, 0x5d, 0xaa, 0x1e, 0x3c, 0xa5, 0xaa, 0x57, 0x62, 0x55, + 0x0f, 0x09, 0x55, 0xcf, 0xf7, 0x43, 0xea, 0xf6, 0xb5, 0x58, 0xe9, 0x9f, 0x01, 0x4a, 0x2a, 0xfc, + 0x38, 0x6b, 0xdf, 0x86, 0x42, 0xe4, 0x23, 0xaa, 0xbe, 0x7a, 0xfd, 0x38, 0xee, 0x65, 0xc4, 0x54, + 0xdd, 0xbe, 0x9c, 0xeb, 0xf6, 0x65, 0xfd, 0x6f, 0x34, 0xb8, 0xd4, 0xeb, 0xc4, 0xe3, 0x7d, 0xf4, + 0x3d, 0xf0, 0x35, 0x28, 0x46, 0xec, 0x58, 0x2d, 0x77, 0xb4, 0x16, 0xba, 0xe5, 0x34, 0x12, 0x00, + 0xfd, 0x0b, 0x0d, 0xa6, 0xc5, 0x5e, 0x3a, 0x6b, 0xce, 0x4d, 0xdc, 0x62, 0xc4, 0xee, 0xbf, 0x95, + 0x2b, 0x30, 0x2c, 0xdf, 0x37, 0xa4, 0xdf, 0x59, 0x18, 0x25, 0x39, 0x26, 0x6b, 0x8a, 0x79, 0x18, + 0x93, 0x1d, 0x4e, 0x97, 0x32, 0x26, 0x3e, 0x1a, 0x6b, 0x79, 0x36, 0x53, 0x7d, 0xfa, 0x51, 0x31, + 0xb5, 0x2e, 0x67, 0xb8, 0xcd, 0x30, 0xf4, 0x26, 0xa0, 0xb6, 0x95, 0xa9, 0x96, 0xbd, 0x51, 0x75, + 0x53, 0x2b, 0x0d, 0x1c, 0x12, 0xfd, 0x7f, 0x34, 0x40, 0x62, 0xf7, 0xf7, 0xc8, 0x7e, 0xdc, 0xda, + 0x63, 0xfd, 0x37, 0xbd, 0x0a, 0xb0, 0xdd, 0x3a, 0x94, 0x97, 0xde, 0x48, 0x81, 0x37, 0xfa, 0x2a, + 0xb0, 0xad, 0x43, 0x66, 0x14, 0xb7, 0x5b, 0x87, 0x8a, 0xcf, 0x87, 0x50, 0x62, 0xc4, 0x71, 0x22, + 0xac, 0xfc, 0x89, 0xb1, 0x80, 0x93, 0x4b, 0x30, 0xfd, 0xfb, 0x1a, 0xd4, 0x22, 0x59, 0x3a, 0xba, + 0x2b, 0x47, 0x48, 0xb4, 0xd1, 0x43, 0xa2, 0xb7, 0x8f, 0xe7, 0x18, 0xbd, 0xe5, 0xba, 0xdf, 0x4b, + 0xae, 0x93, 0x23, 0xa6, 0xa5, 0xfb, 0x0c, 0xc6, 0x85, 0x70, 0x77, 0xb0, 0x67, 0x11, 0xe7, 0x98, + 0x6d, 0xd8, 0x15, 0x18, 0x14, 0x5b, 0x50, 0xb9, 0xee, 0x04, 0x9a, 0x55, 0x37, 0x1e, 0x49, 0xae, + 0x3f, 0x86, 0x0b, 0x82, 0x79, 0xd2, 0x86, 0x7b, 0xd0, 0xb4, 0xe5, 0x87, 0x40, 0x43, 0x92, 0x99, + 0x72, 0xf7, 0x6b, 0x47, 0x71, 0x90, 0xd4, 0x0a, 0x5d, 0xd1, 0xea, 0xff, 0x92, 0x83, 0x29, 0x81, + 0xdf, 0xf1, 0xfe, 0x53, 0x31, 0xb9, 0xdb, 0xc1, 0xe4, 0xcd, 0xe3, 0x29, 0xb2, 0x17, 0x2b, 0x44, + 0xe1, 0x42, 0x33, 0x62, 0x92, 0x7c, 0x96, 0x19, 0x37, 0xd5, 0x16, 0xfa, 0x86, 0xab, 0xee, 0x97, + 0xdf, 0x02, 0x5d, 0x33, 0xc6, 0x9a, 0x3d, 0xde, 0x8b, 0x1b, 0x70, 0x3e, 0xca, 0x07, 0x79, 0x01, + 0x7e, 0xeb, 0x04, 0xe0, 0x2a, 0x01, 0x28, 0xfc, 0x08, 0x48, 0xff, 0xb1, 0x06, 0x33, 0x42, 0x53, + 0x3d, 0x3e, 0x83, 0x78, 0x05, 0xda, 0xda, 0x83, 0x29, 0xf1, 0xcd, 0xc1, 0xa1, 0xb9, 0x23, 0x39, + 0xb5, 0xa9, 0x4c, 0x4a, 0xf5, 0x4e, 0xff, 0x5c, 0xd4, 0xf3, 0x6b, 0x0d, 0x25, 0xd6, 0x24, 0xe9, + 0x3d, 0xad, 0xff, 0x7d, 0x0e, 0xae, 0xf4, 0x32, 0x08, 0xa5, 0x15, 0x25, 0x69, 0x5f, 0xd3, 0x4f, + 0x69, 0x3f, 0x77, 0x2a, 0xed, 0x9f, 0x8b, 0xb5, 0x8f, 0x6e, 0xc0, 0x28, 0x65, 0x1d, 0x1f, 0xf6, + 0xa9, 0xb2, 0xa0, 0x42, 0x59, 0xdb, 0xa7, 0x79, 0xe8, 0x3e, 0x0c, 0xa7, 0xbf, 0x78, 0xc8, 0x58, + 0x12, 0x94, 0x76, 0x92, 0xef, 0x1c, 0xf4, 0x7f, 0xd0, 0x60, 0x42, 0xba, 0x61, 0x9c, 0x91, 0xa2, + 0x97, 0x6c, 0xb3, 0x50, 0x62, 0x81, 0x65, 0x62, 0xdb, 0x0e, 0x08, 0x63, 0x4a, 0x19, 0xc0, 0x02, + 0xeb, 0x7d, 0x39, 0x72, 0xac, 0xbc, 0x8a, 0xde, 0x85, 0x21, 0xec, 0x8a, 0x2e, 0x66, 0xfe, 0x78, + 0x5f, 0x25, 0xab, 0xe5, 0xfa, 0xe7, 0x51, 0x85, 0x99, 0xec, 0xec, 0x21, 0x0d, 0x1b, 0x76, 0x80, + 0xf7, 0x8f, 0x57, 0x9d, 0xcf, 0x42, 0xc9, 0x66, 0x61, 0xbc, 0x7f, 0xf5, 0x5d, 0x9f, 0xcd, 0xc2, + 0x68, 0xff, 0x99, 0xb7, 0xf6, 0x1f, 0x91, 0xc7, 0x24, 0x5b, 0x53, 0xef, 0xf9, 0xb6, 0x02, 0xec, + 0xb1, 0x1d, 0x12, 0xf0, 0x63, 0xe5, 0xca, 0xeb, 0xf5, 0xde, 0xae, 0xc2, 0x02, 0xab, 0x9e, 0xde, + 0xe8, 0x0d, 0x18, 0xe5, 0x1b, 0xed, 0xd6, 0x65, 0xd1, 0xa8, 0xd8, 0x2c, 0xac, 0x9f, 0x89, 0x3a, + 0xf7, 0x61, 0xb4, 0xfb, 0x88, 0x8f, 0xa5, 0xc7, 0xf7, 0xe0, 0xbc, 0x2d, 0xd7, 0x2b, 0xab, 0x7f, + 0xad, 0xbf, 0xf7, 0x8b, 0xa5, 0x46, 0x44, 0xa3, 0x37, 0xa1, 0xac, 0xc6, 0x94, 0x8b, 0x8d, 0xc3, + 0xa0, 0xfc, 0x2e, 0x40, 0xaa, 0x43, 0x3e, 0xa0, 0x55, 0x28, 0x28, 0x8a, 0x28, 0x5b, 0xbe, 0x75, + 0xbc, 0x02, 0x2a, 0x62, 0x18, 0x93, 0xeb, 0x6e, 0xfa, 0x6a, 0xd2, 0xce, 0xdb, 0x80, 0x8a, 0x5a, + 0x66, 0xb6, 0xc4, 0x08, 0xb7, 0xeb, 0xfc, 0x51, 0x57, 0xb6, 0x36, 0x0c, 0x63, 0xc4, 0x4e, 0x3f, + 0x32, 0xfd, 0xff, 0x34, 0x98, 0xee, 0xd9, 0x1c, 0x94, 0x69, 0x15, 0x7d, 0x04, 0xc3, 0x2a, 0xa4, + 0xc8, 0xbc, 0x29, 0x43, 0xe8, 0xcd, 0x93, 0x84, 0xd0, 0x24, 0x7d, 0x6a, 0x46, 0xc9, 0x4d, 0xb5, + 0x1f, 0x1f, 0x42, 0xc5, 0x12, 0x5c, 0x4e, 0x7b, 0x9b, 0x1f, 0x91, 0x30, 0x71, 0xbb, 0x3d, 0x4e, + 0x9f, 0x52, 0x88, 0x13, 0xbd, 0x59, 0x7a, 0x1d, 0xc4, 0x85, 0xc6, 0xa5, 0x8a, 0x58, 0x5d, 0x82, + 0xda, 0x07, 0xd1, 0x43, 0x28, 0xa5, 0xde, 0x74, 0x28, 0x73, 0x3e, 0x71, 0x3d, 0xa3, 0x94, 0x02, + 0x4e, 0xd2, 0x46, 0x77, 0x61, 0x2c, 0xad, 0x6f, 0x53, 0x4a, 0x26, 0x82, 0x65, 0xe9, 0xd6, 0xbb, + 0x27, 0x56, 0xbb, 0xdc, 0xae, 0xe2, 0x33, 0xea, 0x76, 0x4e, 0xe8, 0xff, 0x9d, 0x87, 0x49, 0x79, + 0x7b, 0xa3, 0xe1, 0xe1, 0x3a, 0xf5, 0xa8, 0xb7, 0x7b, 0x07, 0xbb, 0x4d, 0x4c, 0x77, 0x3d, 0x74, + 0x0d, 0x2a, 0x6d, 0x3f, 0x0c, 0xb1, 0xa5, 0xb9, 0x15, 0x8d, 0x72, 0xea, 0x77, 0x1e, 0x36, 0x43, + 0x7f, 0x09, 0x63, 0xe9, 0x75, 0xfb, 0x84, 0xee, 0x36, 0x94, 0x1f, 0x64, 0x68, 0xcc, 0x24, 0xd8, + 0x0f, 0x25, 0x10, 0xba, 0x05, 0x17, 0x7a, 0xfc, 0x72, 0xc4, 0x96, 0x55, 0x64, 0xd1, 0x18, 0xeb, + 0xfa, 0x21, 0x88, 0xcd, 0xd0, 0x27, 0x70, 0xb1, 0x9b, 0x26, 0xda, 0xd9, 0x40, 0xa6, 0x9d, 0x4d, + 0x76, 0xf2, 0x89, 0xf6, 0xb7, 0x0f, 0xa3, 0x2e, 0x3e, 0x30, 0x49, 0xd3, 0xb7, 0x1a, 0x66, 0x40, + 0xf6, 0x71, 0x60, 0xb3, 0xda, 0xa0, 0x70, 0xcc, 0x3e, 0x01, 0xee, 0x6d, 0xce, 0xfe, 0xdf, 0x7e, + 0x38, 0x7b, 0xfd, 0x18, 0xec, 0x39, 0x01, 0x33, 0x2a, 0x2e, 0x3e, 0x58, 0xe6, 0x4c, 0x0c, 0xc9, + 0xe3, 0x86, 0x05, 0xc3, 0xe9, 0x0f, 0x66, 0x50, 0x05, 0x4a, 0x0f, 0x3c, 0xd6, 0x24, 0x16, 0xdd, + 0xa1, 0xc4, 0xae, 0x9e, 0x43, 0x00, 0x43, 0xef, 0x0b, 0x6b, 0xa9, 0x6a, 0xfc, 0x7f, 0x79, 0x01, + 0xab, 0xe6, 0x50, 0x19, 0x8a, 0xf5, 0x16, 0x6b, 0x12, 0xcf, 0x26, 0x76, 0x35, 0x8f, 0x46, 0x00, + 0x96, 0x88, 0xeb, 0x3b, 0x94, 0x35, 0x88, 0x5d, 0x1d, 0x40, 0x25, 0x38, 0x2f, 0xca, 0x14, 0x62, + 0x57, 0x07, 0x6f, 0x7c, 0x19, 0x7d, 0xcd, 0x21, 0x6e, 0xcb, 0x73, 0x50, 0x7a, 0x70, 0xaf, 0xbe, + 0xb9, 0x7c, 0x67, 0x75, 0x65, 0x75, 0x79, 0xa9, 0x7a, 0x6e, 0xaa, 0xf2, 0xec, 0xf9, 0x5c, 0x7a, + 0x08, 0x55, 0x21, 0xbf, 0xf8, 0xe0, 0x51, 0x55, 0x9b, 0x3a, 0xff, 0xec, 0xf9, 0x1c, 0xff, 0x17, + 0x21, 0x18, 0xa8, 0x2f, 0xaf, 0xad, 0x55, 0x73, 0x53, 0x85, 0x67, 0xcf, 0xe7, 0xc4, 0xff, 0x68, + 0x0a, 0x0a, 0xf5, 0xad, 0x8d, 0x4d, 0x93, 0x2f, 0xcd, 0x4f, 0x0d, 0x3f, 0x7b, 0x3e, 0x17, 0x3f, + 0xa3, 0x4b, 0x50, 0x14, 0xff, 0x0b, 0xa2, 0x81, 0xa9, 0xf2, 0xb3, 0xe7, 0x73, 0xc9, 0x00, 0xa7, + 0xdc, 0x7a, 0xff, 0xc3, 0x65, 0x41, 0x39, 0x28, 0x29, 0xa3, 0x67, 0x4e, 0x29, 0xfe, 0x17, 0x94, + 0x43, 0x92, 0x32, 0x1e, 0xb8, 0xf1, 0x57, 0x50, 0x6e, 0xeb, 0x04, 0xa0, 0x4b, 0x50, 0x4b, 0xe9, + 0xab, 0x6d, 0x4e, 0x2a, 0x4f, 0x6a, 0xb7, 0xaa, 0x71, 0x85, 0x09, 0xaf, 0x5d, 0xa1, 0x8e, 0x53, + 0xcd, 0xa1, 0x29, 0x98, 0x10, 0x8f, 0xeb, 0x3c, 0x46, 0x1b, 0x44, 0xfc, 0xe0, 0x48, 0xe8, 0xa8, + 0x9a, 0x47, 0x13, 0x80, 0x92, 0xb9, 0x7b, 0x64, 0x5f, 0x8e, 0x0f, 0x2c, 0x36, 0xbe, 0x7a, 0x31, + 0xa3, 0x7d, 0xfd, 0x62, 0x46, 0xfb, 0xd1, 0x8b, 0x19, 0xed, 0xef, 0xbe, 0x9b, 0x39, 0xf7, 0xf5, + 0x77, 0x33, 0xe7, 0xfe, 0xff, 0xbb, 0x99, 0x73, 0x1f, 0xdd, 0x4b, 0x59, 0xc0, 0x6a, 0xe4, 0xdf, + 0x6b, 0x78, 0x9b, 0x2d, 0xc4, 0xde, 0xfe, 0x96, 0xe5, 0x07, 0x24, 0xfd, 0xd8, 0xc0, 0xd4, 0x5b, + 0x70, 0x7d, 0xbb, 0xe5, 0x10, 0x96, 0xfc, 0xca, 0x4c, 0x58, 0xcb, 0xf6, 0x90, 0xf8, 0x89, 0xd7, + 0x3b, 0xbf, 0x09, 0x00, 0x00, 0xff, 0xff, 0x6f, 0xb6, 0x42, 0xa2, 0x88, 0x36, 0x00, 0x00, } func (this *Params) Equal(that interface{}) bool { @@ -5704,6 +5780,89 @@ func (m *EventCancelDerivativeOrder) MarshalToSizedBuffer(dAtA []byte) (int, err return len(dAtA) - i, nil } +func (m *LiquidityMiningCampaign) 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 *LiquidityMiningCampaign) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LiquidityMiningCampaign) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.MaxEpochRewards) > 0 { + for iNdEx := len(m.MaxEpochRewards) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.MaxEpochRewards[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintExchange(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + if len(m.DerivativeMarketWeights) > 0 { + for iNdEx := len(m.DerivativeMarketWeights) - 1; iNdEx >= 0; iNdEx-- { + { + size := m.DerivativeMarketWeights[iNdEx].Size() + i -= size + if _, err := m.DerivativeMarketWeights[iNdEx].MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintExchange(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if len(m.DerivativeMarketIds) > 0 { + for iNdEx := len(m.DerivativeMarketIds) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.DerivativeMarketIds[iNdEx]) + copy(dAtA[i:], m.DerivativeMarketIds[iNdEx]) + i = encodeVarintExchange(dAtA, i, uint64(len(m.DerivativeMarketIds[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + if len(m.SpotMarketWeights) > 0 { + for iNdEx := len(m.SpotMarketWeights) - 1; iNdEx >= 0; iNdEx-- { + { + size := m.SpotMarketWeights[iNdEx].Size() + i -= size + if _, err := m.SpotMarketWeights[iNdEx].MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintExchange(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.SpotMarketIds) > 0 { + for iNdEx := len(m.SpotMarketIds) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.SpotMarketIds[iNdEx]) + copy(dAtA[i:], m.SpotMarketIds[iNdEx]) + i = encodeVarintExchange(dAtA, i, uint64(len(m.SpotMarketIds[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + func encodeVarintExchange(dAtA []byte, offset int, v uint64) int { offset -= sovExchange(v) base := offset @@ -6658,6 +6817,45 @@ func (m *EventCancelDerivativeOrder) Size() (n int) { return n } +func (m *LiquidityMiningCampaign) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.SpotMarketIds) > 0 { + for _, s := range m.SpotMarketIds { + l = len(s) + n += 1 + l + sovExchange(uint64(l)) + } + } + if len(m.SpotMarketWeights) > 0 { + for _, e := range m.SpotMarketWeights { + l = e.Size() + n += 1 + l + sovExchange(uint64(l)) + } + } + if len(m.DerivativeMarketIds) > 0 { + for _, s := range m.DerivativeMarketIds { + l = len(s) + n += 1 + l + sovExchange(uint64(l)) + } + } + if len(m.DerivativeMarketWeights) > 0 { + for _, e := range m.DerivativeMarketWeights { + l = e.Size() + n += 1 + l + sovExchange(uint64(l)) + } + } + if len(m.MaxEpochRewards) > 0 { + for _, e := range m.MaxEpochRewards { + l = e.Size() + n += 1 + l + sovExchange(uint64(l)) + } + } + return n +} + func sovExchange(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -14345,6 +14543,226 @@ func (m *EventCancelDerivativeOrder) Unmarshal(dAtA []byte) error { } return nil } +func (m *LiquidityMiningCampaign) 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 ErrIntOverflowExchange + } + 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: LiquidityMiningCampaign: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LiquidityMiningCampaign: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SpotMarketIds", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExchange + } + 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 ErrInvalidLengthExchange + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthExchange + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SpotMarketIds = append(m.SpotMarketIds, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SpotMarketWeights", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExchange + } + 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 ErrInvalidLengthExchange + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthExchange + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Dec + m.SpotMarketWeights = append(m.SpotMarketWeights, v) + if err := m.SpotMarketWeights[len(m.SpotMarketWeights)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DerivativeMarketIds", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExchange + } + 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 ErrInvalidLengthExchange + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthExchange + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DerivativeMarketIds = append(m.DerivativeMarketIds, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DerivativeMarketWeights", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExchange + } + 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 ErrInvalidLengthExchange + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthExchange + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Dec + m.DerivativeMarketWeights = append(m.DerivativeMarketWeights, v) + if err := m.DerivativeMarketWeights[len(m.DerivativeMarketWeights)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxEpochRewards", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExchange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthExchange + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthExchange + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MaxEpochRewards = append(m.MaxEpochRewards, types.Coin{}) + if err := m.MaxEpochRewards[len(m.MaxEpochRewards)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipExchange(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthExchange + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipExchange(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/chain/exchange/types/expected_keepers.go b/chain/exchange/types/expected_keepers.go index 668b6210..845474ba 100644 --- a/chain/exchange/types/expected_keepers.go +++ b/chain/exchange/types/expected_keepers.go @@ -4,6 +4,7 @@ import ( "time" sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/distribution/types" "github.com/ethereum/go-ethereum/common" govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" @@ -45,3 +46,13 @@ type GovKeeper interface { IterateActiveProposalsQueue(ctx sdk.Context, endTime time.Time, cb func(proposal govtypes.Proposal) (stop bool)) GetVotingParams(ctx sdk.Context) govtypes.VotingParams } + +type AuctionKeeper interface { + GetEndingTimeStamp(ctx sdk.Context) int64 + GetNextEndingTimeStamp(ctx sdk.Context) int64 +} + +type DistributionKeeper interface { + GetFeePool(ctx sdk.Context) (feePool types.FeePool) + DistributeFromFeePool(ctx sdk.Context, amount sdk.Coins, receiveAddr sdk.AccAddress) error +} diff --git a/chain/exchange/types/genesis.pb.go b/chain/exchange/types/genesis.pb.go index 2d699ae1..35ead205 100644 --- a/chain/exchange/types/genesis.pb.go +++ b/chain/exchange/types/genesis.pb.go @@ -5,6 +5,7 @@ package types import ( fmt "fmt" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" io "io" @@ -51,6 +52,9 @@ type GenesisState struct { DerivativeMarketSettlementScheduled []DerivativeMarketSettlementInfo `protobuf:"bytes,12,rep,name=derivative_market_settlement_scheduled,json=derivativeMarketSettlementScheduled,proto3" json:"derivative_market_settlement_scheduled"` IsSpotExchangeEnabled bool `protobuf:"varint,13,opt,name=is_spot_exchange_enabled,json=isSpotExchangeEnabled,proto3" json:"is_spot_exchange_enabled,omitempty"` IsDerivativesExchangeEnabled bool `protobuf:"varint,14,opt,name=is_derivatives_exchange_enabled,json=isDerivativesExchangeEnabled,proto3" json:"is_derivatives_exchange_enabled,omitempty"` + LiquidityMiningAccountPoints []LiquidityMiningAccountPoints `protobuf:"bytes,15,rep,name=liquidity_mining_account_points,json=liquidityMiningAccountPoints,proto3" json:"liquidity_mining_account_points"` + CurrentLiquidityMiningCampaign *LiquidityMiningCampaign `protobuf:"bytes,16,opt,name=current_liquidity_mining_campaign,json=currentLiquidityMiningCampaign,proto3" json:"current_liquidity_mining_campaign,omitempty"` + UpcomingLiquidityMiningCampaign *LiquidityMiningCampaign `protobuf:"bytes,17,opt,name=upcoming_liquidity_mining_campaign,json=upcomingLiquidityMiningCampaign,proto3" json:"upcoming_liquidity_mining_campaign,omitempty"` } func (m *GenesisState) Reset() { *m = GenesisState{} } @@ -184,6 +188,27 @@ func (m *GenesisState) GetIsDerivativesExchangeEnabled() bool { return false } +func (m *GenesisState) GetLiquidityMiningAccountPoints() []LiquidityMiningAccountPoints { + if m != nil { + return m.LiquidityMiningAccountPoints + } + return nil +} + +func (m *GenesisState) GetCurrentLiquidityMiningCampaign() *LiquidityMiningCampaign { + if m != nil { + return m.CurrentLiquidityMiningCampaign + } + return nil +} + +func (m *GenesisState) GetUpcomingLiquidityMiningCampaign() *LiquidityMiningCampaign { + if m != nil { + return m.UpcomingLiquidityMiningCampaign + } + return nil +} + // Spot Exchange Limit Orderbook type SpotOrderBook struct { MarketId string `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"` @@ -484,6 +509,44 @@ func (m *PerpetualMarketFundingState) GetFunding() *PerpetualMarketFunding { return nil } +type LiquidityMiningAccountPoints struct { + Account string `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"` + Points github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=points,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"points"` +} + +func (m *LiquidityMiningAccountPoints) Reset() { *m = LiquidityMiningAccountPoints{} } +func (m *LiquidityMiningAccountPoints) String() string { return proto.CompactTextString(m) } +func (*LiquidityMiningAccountPoints) ProtoMessage() {} +func (*LiquidityMiningAccountPoints) Descriptor() ([]byte, []int) { + return fileDescriptor_c47ec6b98758ed05, []int{8} +} +func (m *LiquidityMiningAccountPoints) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LiquidityMiningAccountPoints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LiquidityMiningAccountPoints.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 *LiquidityMiningAccountPoints) XXX_Merge(src proto.Message) { + xxx_messageInfo_LiquidityMiningAccountPoints.Merge(m, src) +} +func (m *LiquidityMiningAccountPoints) XXX_Size() int { + return m.Size() +} +func (m *LiquidityMiningAccountPoints) XXX_DiscardUnknown() { + xxx_messageInfo_LiquidityMiningAccountPoints.DiscardUnknown(m) +} + +var xxx_messageInfo_LiquidityMiningAccountPoints proto.InternalMessageInfo + func init() { proto.RegisterType((*GenesisState)(nil), "injective.exchange.v1beta1.GenesisState") proto.RegisterType((*SpotOrderBook)(nil), "injective.exchange.v1beta1.SpotOrderBook") @@ -493,6 +556,7 @@ func init() { proto.RegisterType((*SubaccountNonce)(nil), "injective.exchange.v1beta1.SubaccountNonce") proto.RegisterType((*ExpiryFuturesMarketInfoState)(nil), "injective.exchange.v1beta1.ExpiryFuturesMarketInfoState") proto.RegisterType((*PerpetualMarketFundingState)(nil), "injective.exchange.v1beta1.PerpetualMarketFundingState") + proto.RegisterType((*LiquidityMiningAccountPoints)(nil), "injective.exchange.v1beta1.LiquidityMiningAccountPoints") } func init() { @@ -500,64 +564,73 @@ func init() { } var fileDescriptor_c47ec6b98758ed05 = []byte{ - // 898 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x96, 0xcd, 0x6f, 0x1b, 0x45, - 0x18, 0xc6, 0x3d, 0x69, 0x9b, 0xd8, 0xaf, 0x93, 0x22, 0xa6, 0x09, 0xac, 0x92, 0xc8, 0xb6, 0x1c, - 0x54, 0xb9, 0x7c, 0x78, 0x69, 0x7a, 0x28, 0xea, 0x85, 0xca, 0xaa, 0x0b, 0x96, 0x42, 0x89, 0xd6, - 0x15, 0x07, 0x38, 0xac, 0xf6, 0x63, 0x6c, 0x0f, 0xf1, 0xee, 0xac, 0x76, 0x66, 0xa3, 0xe6, 0xca, - 0x01, 0xf5, 0x06, 0x1c, 0x90, 0x38, 0x56, 0x88, 0x33, 0x7f, 0x47, 0x8f, 0xe5, 0xc6, 0x09, 0xa1, - 0xe4, 0xc2, 0x9f, 0x81, 0x76, 0x76, 0xf6, 0x23, 0xb6, 0xb3, 0x76, 0xe0, 0x36, 0x9e, 0x79, 0xdf, - 0xe7, 0xf9, 0xed, 0x7c, 0x3c, 0x32, 0x74, 0xa8, 0xff, 0x2d, 0x71, 0x04, 0x3d, 0x25, 0x3a, 0x79, - 0xe1, 0x4c, 0x2c, 0x7f, 0x4c, 0xf4, 0xd3, 0xfb, 0x36, 0x11, 0xd6, 0x7d, 0x7d, 0x4c, 0x7c, 0xc2, - 0x29, 0xef, 0x06, 0x21, 0x13, 0x0c, 0xef, 0x66, 0x95, 0xdd, 0xb4, 0xb2, 0xab, 0x2a, 0x77, 0xef, - 0x95, 0xa8, 0x64, 0xc5, 0x52, 0x66, 0x77, 0x7b, 0xcc, 0xc6, 0x4c, 0x0e, 0xf5, 0x78, 0x94, 0xcc, - 0xb6, 0xff, 0x00, 0xd8, 0xfc, 0x2c, 0xb1, 0x1b, 0x0a, 0x4b, 0x10, 0xfc, 0x18, 0xd6, 0x03, 0x2b, - 0xb4, 0x3c, 0xae, 0xa1, 0x16, 0xea, 0xd4, 0x0f, 0xdb, 0xdd, 0xab, 0xed, 0xbb, 0xc7, 0xb2, 0xb2, - 0x77, 0xf3, 0xf5, 0x5f, 0xcd, 0x8a, 0xa1, 0xfa, 0xf0, 0x00, 0x36, 0x79, 0xc0, 0x84, 0xe9, 0x59, - 0xe1, 0x09, 0x11, 0x5c, 0x5b, 0x6b, 0xdd, 0xe8, 0xd4, 0x0f, 0xef, 0x96, 0xe9, 0x0c, 0x03, 0x26, - 0xbe, 0x90, 0xe5, 0x46, 0x9d, 0x67, 0x63, 0x8e, 0xbf, 0x01, 0xec, 0x92, 0x90, 0x9e, 0x5a, 0x71, - 0x5b, 0x26, 0x78, 0x43, 0x0a, 0x7e, 0x58, 0x26, 0xf8, 0x24, 0xeb, 0x52, 0xb2, 0x6f, 0xbb, 0x33, - 0x33, 0x1c, 0x7f, 0x05, 0xb7, 0x25, 0x27, 0x0b, 0x5d, 0x12, 0xda, 0x8c, 0x9d, 0x68, 0x37, 0xa5, - 0xf0, 0xbd, 0x65, 0xa4, 0x5f, 0xc6, 0x0d, 0x3d, 0xc6, 0x4e, 0xd4, 0x87, 0x6f, 0xf1, 0x74, 0x32, - 0x56, 0xc1, 0x13, 0xd8, 0x2e, 0x40, 0xe7, 0xea, 0xb7, 0xa4, 0xba, 0xbe, 0x1a, 0xf6, 0xac, 0xc7, - 0x1d, 0xf7, 0xf2, 0x92, 0x74, 0xea, 0x43, 0xd5, 0xb6, 0xa6, 0x96, 0xef, 0x10, 0xae, 0xad, 0x4b, - 0xf5, 0x83, 0x32, 0xf5, 0x5e, 0x52, 0xab, 0x14, 0xb3, 0x56, 0x6c, 0x40, 0x2d, 0x60, 0x9c, 0x0a, - 0xca, 0x7c, 0xae, 0x6d, 0x48, 0x9d, 0xee, 0x6a, 0x94, 0xc7, 0xaa, 0x4d, 0x49, 0xe6, 0x32, 0x98, - 0xc2, 0xbb, 0x3c, 0xb2, 0x2d, 0xc7, 0x61, 0x91, 0x2f, 0x4c, 0x11, 0x5a, 0x2e, 0x31, 0x7d, 0x26, - 0x49, 0xab, 0xd2, 0xe1, 0x83, 0xd2, 0x5d, 0xce, 0x5a, 0x9f, 0xb1, 0x9c, 0x78, 0x27, 0x57, 0x7c, - 0x1e, 0x0b, 0xca, 0x35, 0x8e, 0xbf, 0x47, 0xd0, 0x22, 0x2f, 0x02, 0x1a, 0x9e, 0x99, 0xa3, 0x48, - 0x44, 0x21, 0xe1, 0xea, 0xa6, 0x98, 0xd4, 0x1f, 0x31, 0x93, 0xc7, 0xd7, 0x5a, 0xab, 0x49, 0xd3, - 0x4f, 0xca, 0x4c, 0xfb, 0x52, 0xe3, 0x69, 0x22, 0x91, 0x5c, 0x92, 0x81, 0x3f, 0x62, 0xf2, 0x59, - 0x28, 0x82, 0x7d, 0x52, 0x52, 0x83, 0x29, 0xec, 0x04, 0x24, 0x0c, 0x88, 0x88, 0xac, 0x69, 0x11, - 0x41, 0x83, 0xe5, 0x27, 0x7f, 0x9c, 0x36, 0xe6, 0xa2, 0xe9, 0xc9, 0x07, 0xf3, 0x4b, 0xf8, 0x3b, - 0x04, 0x8d, 0x39, 0xaf, 0x51, 0xe4, 0xbb, 0xd4, 0x1f, 0xab, 0x2f, 0xae, 0x4b, 0xd3, 0x87, 0xd7, - 0x30, 0x7d, 0x9a, 0xf4, 0x17, 0x3f, 0x78, 0x2f, 0xb8, 0xba, 0x04, 0xff, 0x8c, 0xe0, 0xee, 0xdc, - 0xf3, 0x34, 0x39, 0x11, 0x62, 0x4a, 0x3c, 0xe2, 0x0b, 0x93, 0x3b, 0x13, 0xe2, 0x46, 0x53, 0xe2, - 0x6a, 0x9b, 0x12, 0xe6, 0xd1, 0x75, 0x9e, 0xec, 0x30, 0xd3, 0x29, 0x6c, 0xc6, 0x81, 0x7b, 0x65, - 0xd5, 0x30, 0x35, 0xc3, 0x0f, 0x41, 0xa3, 0xdc, 0x94, 0x6f, 0x3b, 0x75, 0x31, 0x89, 0x6f, 0xd9, - 0x31, 0xc8, 0x56, 0x0b, 0x75, 0xaa, 0xc6, 0x0e, 0xe5, 0xf1, 0x43, 0xee, 0xab, 0xd5, 0x7e, 0xb2, - 0x88, 0xfb, 0xd0, 0xa4, 0xdc, 0xcc, 0x2d, 0xf8, 0x7c, 0xff, 0x6d, 0xd9, 0xbf, 0x4f, 0x79, 0x8e, - 0xcb, 0x67, 0x64, 0xda, 0xbf, 0x20, 0xd8, 0xba, 0x94, 0x13, 0x78, 0x0f, 0x6a, 0xe9, 0x7d, 0x70, - 0x65, 0xae, 0xd6, 0x8c, 0x6a, 0x32, 0x31, 0x70, 0xf1, 0x3e, 0xd4, 0x28, 0xef, 0x45, 0x67, 0x43, - 0xea, 0x12, 0x6d, 0x4d, 0xea, 0xe7, 0x13, 0xb8, 0x07, 0xeb, 0x32, 0x42, 0xd2, 0xd8, 0x7b, 0x7f, - 0x59, 0x3a, 0x1d, 0x51, 0x8f, 0x26, 0xd6, 0x86, 0xea, 0x7c, 0x54, 0x7d, 0xf9, 0xaa, 0x59, 0xf9, - 0xe7, 0x55, 0xb3, 0xd2, 0xfe, 0x0d, 0xc1, 0x9d, 0x05, 0x21, 0xf3, 0x7f, 0x00, 0x3f, 0x9f, 0x01, - 0xfc, 0x78, 0xb5, 0x43, 0x2e, 0xc5, 0xfc, 0x01, 0xc1, 0x86, 0x4a, 0x2b, 0x7c, 0x00, 0x5b, 0x85, - 0x24, 0xc9, 0xf0, 0x36, 0xf3, 0xc9, 0x81, 0x8b, 0xb7, 0xe1, 0x96, 0x4b, 0x7c, 0xe6, 0x49, 0xbc, - 0x9a, 0x91, 0xfc, 0xc0, 0x9f, 0x42, 0xd5, 0x25, 0x32, 0x93, 0x62, 0x38, 0xb4, 0x2c, 0x1f, 0x9f, - 0x24, 0xb5, 0x46, 0xd6, 0x54, 0x20, 0xfa, 0x15, 0x01, 0x9e, 0xcf, 0xbd, 0xd5, 0xe0, 0x2e, 0x6d, - 0xee, 0xda, 0xcc, 0xe6, 0x3e, 0x86, 0x6a, 0x9a, 0x9a, 0x8a, 0xf1, 0xbd, 0xd2, 0x27, 0xab, 0x6a, - 0x8d, 0xac, 0xab, 0x00, 0xf9, 0x3b, 0x82, 0xb7, 0x66, 0xa2, 0x73, 0x35, 0xc2, 0x29, 0xbc, 0xb3, - 0x38, 0xad, 0x25, 0xee, 0x92, 0x33, 0x1d, 0x2e, 0x48, 0x65, 0xf5, 0x5c, 0xb7, 0x17, 0x25, 0x76, - 0x01, 0xf8, 0x27, 0x04, 0xfb, 0x65, 0xb1, 0x5b, 0x7e, 0x2f, 0x9f, 0x43, 0xbd, 0x98, 0xb2, 0x09, - 0xea, 0x83, 0xff, 0x10, 0xf1, 0x06, 0x78, 0xd9, 0xb8, 0xfd, 0x12, 0xc1, 0x5e, 0x49, 0x30, 0x96, - 0x23, 0x1d, 0xc1, 0x86, 0x4a, 0x61, 0x85, 0x73, 0x78, 0xfd, 0xfc, 0x35, 0x52, 0x89, 0xde, 0xe4, - 0xf5, 0x79, 0x03, 0xbd, 0x39, 0x6f, 0xa0, 0xbf, 0xcf, 0x1b, 0xe8, 0xc7, 0x8b, 0x46, 0xe5, 0xcd, - 0x45, 0xa3, 0xf2, 0xe7, 0x45, 0xa3, 0xf2, 0xf5, 0xb3, 0x31, 0x15, 0x93, 0xc8, 0xee, 0x3a, 0xcc, - 0xd3, 0x07, 0xa9, 0xc1, 0x91, 0x65, 0x73, 0x3d, 0xb3, 0xfb, 0xc8, 0x61, 0x21, 0x29, 0xfe, 0x9c, - 0x58, 0xd4, 0xd7, 0x3d, 0x16, 0x67, 0x24, 0xcf, 0xff, 0x2d, 0x8a, 0xb3, 0x80, 0x70, 0x7b, 0x5d, - 0xfe, 0x1b, 0x7c, 0xf0, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x9a, 0xeb, 0x3d, 0x03, 0x96, 0x0a, - 0x00, 0x00, + // 1056 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0x4f, 0x6f, 0x1b, 0xc5, + 0x1b, 0xf6, 0xa4, 0x6d, 0x62, 0xbf, 0x8e, 0xdb, 0x5f, 0xa7, 0xc9, 0x8f, 0x55, 0x62, 0xd9, 0xc1, + 0x41, 0x51, 0x0a, 0xd4, 0xa6, 0xe9, 0xa1, 0xa8, 0x17, 0x8a, 0x89, 0x03, 0x96, 0xd2, 0x12, 0xad, + 0x2b, 0x0e, 0x70, 0x58, 0xad, 0x77, 0x27, 0xf6, 0x10, 0xef, 0xce, 0xb2, 0x33, 0x1b, 0x35, 0x17, + 0x84, 0x90, 0x40, 0x15, 0x17, 0xe0, 0x80, 0xc4, 0xb1, 0x42, 0x9c, 0xf9, 0x1c, 0x3d, 0xf6, 0x88, + 0x10, 0xaa, 0x50, 0x72, 0xe1, 0x63, 0xa0, 0x9d, 0x9d, 0xfd, 0x13, 0x3b, 0x5e, 0x3b, 0x70, 0xf2, + 0xec, 0xcc, 0xfb, 0x3e, 0xcf, 0x33, 0x7f, 0xde, 0xf7, 0x91, 0x61, 0x9b, 0xba, 0x9f, 0x13, 0x4b, + 0xd0, 0x63, 0xd2, 0x22, 0x4f, 0xad, 0xa1, 0xe9, 0x0e, 0x48, 0xeb, 0xf8, 0x6e, 0x9f, 0x08, 0xf3, + 0x6e, 0x6b, 0x40, 0x5c, 0xc2, 0x29, 0x6f, 0x7a, 0x3e, 0x13, 0x0c, 0xaf, 0x25, 0x91, 0xcd, 0x38, + 0xb2, 0xa9, 0x22, 0xd7, 0x6e, 0xe7, 0xa0, 0x24, 0xc1, 0x12, 0x66, 0x6d, 0x65, 0xc0, 0x06, 0x4c, + 0x0e, 0x5b, 0xe1, 0x28, 0x9a, 0x6d, 0xfc, 0x59, 0x81, 0xe5, 0x0f, 0x23, 0xba, 0x9e, 0x30, 0x05, + 0xc1, 0x0f, 0x61, 0xd1, 0x33, 0x7d, 0xd3, 0xe1, 0x1a, 0xda, 0x40, 0xdb, 0xe5, 0x9d, 0x46, 0x73, + 0x3a, 0x7d, 0xf3, 0x40, 0x46, 0xb6, 0xaf, 0xbe, 0x78, 0x55, 0x2f, 0xe8, 0x2a, 0x0f, 0x77, 0x61, + 0x99, 0x7b, 0x4c, 0x18, 0x8e, 0xe9, 0x1f, 0x11, 0xc1, 0xb5, 0x85, 0x8d, 0x2b, 0xdb, 0xe5, 0x9d, + 0xad, 0x3c, 0x9c, 0x9e, 0xc7, 0xc4, 0x23, 0x19, 0xae, 0x97, 0x79, 0x32, 0xe6, 0xf8, 0x33, 0xc0, + 0x36, 0xf1, 0xe9, 0xb1, 0x19, 0xa6, 0x25, 0x80, 0x57, 0x24, 0xe0, 0xdb, 0x79, 0x80, 0xbb, 0x49, + 0x96, 0x82, 0xbd, 0x69, 0x8f, 0xcd, 0x70, 0xfc, 0x09, 0x5c, 0x97, 0x3a, 0x99, 0x6f, 0x13, 0xbf, + 0xcf, 0xd8, 0x91, 0x76, 0x55, 0x02, 0xdf, 0x9e, 0xa5, 0xf4, 0xe3, 0x30, 0xa1, 0xcd, 0xd8, 0x91, + 0xda, 0x78, 0x85, 0xc7, 0x93, 0x21, 0x0a, 0x1e, 0xc2, 0x4a, 0x46, 0x74, 0x8a, 0x7e, 0x4d, 0xa2, + 0xb7, 0xe6, 0x93, 0x3d, 0xce, 0x71, 0xcb, 0x3e, 0xbf, 0x24, 0x99, 0x3a, 0x50, 0xec, 0x9b, 0x23, + 0xd3, 0xb5, 0x08, 0xd7, 0x16, 0x25, 0xfa, 0x66, 0x1e, 0x7a, 0x3b, 0x8a, 0x55, 0x88, 0x49, 0x2a, + 0xd6, 0xa1, 0xe4, 0x31, 0x4e, 0x05, 0x65, 0x2e, 0xd7, 0x96, 0x24, 0x4e, 0x73, 0x3e, 0x95, 0x07, + 0x2a, 0x4d, 0x41, 0xa6, 0x30, 0x98, 0xc2, 0x6b, 0x3c, 0xe8, 0x9b, 0x96, 0xc5, 0x02, 0x57, 0x18, + 0xc2, 0x37, 0x6d, 0x62, 0xb8, 0x4c, 0x2a, 0x2d, 0x4a, 0x86, 0xb7, 0x72, 0x4f, 0x39, 0x49, 0x7d, + 0xcc, 0x52, 0xc5, 0xab, 0x29, 0xe2, 0x93, 0x10, 0x50, 0xae, 0x71, 0xfc, 0x2d, 0x82, 0x0d, 0xf2, + 0xd4, 0xa3, 0xfe, 0x89, 0x71, 0x18, 0x88, 0xc0, 0x27, 0x5c, 0xbd, 0x14, 0x83, 0xba, 0x87, 0xcc, + 0xe0, 0xe1, 0xb3, 0xd6, 0x4a, 0x92, 0xf4, 0xdd, 0x3c, 0xd2, 0x8e, 0xc4, 0xd8, 0x8b, 0x20, 0xa2, + 0x47, 0xd2, 0x75, 0x0f, 0x99, 0x2c, 0x0b, 0xa5, 0xa0, 0x4a, 0x72, 0x62, 0x30, 0x85, 0x55, 0x8f, + 0xf8, 0x1e, 0x11, 0x81, 0x39, 0xca, 0x4a, 0xd0, 0x60, 0xf6, 0xcd, 0x1f, 0xc4, 0x89, 0x29, 0x68, + 0x7c, 0xf3, 0xde, 0xe4, 0x12, 0xfe, 0x1a, 0x41, 0x6d, 0x82, 0xeb, 0x30, 0x70, 0x6d, 0xea, 0x0e, + 0xd4, 0x8e, 0xcb, 0x92, 0xf4, 0xfe, 0x25, 0x48, 0xf7, 0xa2, 0xfc, 0xec, 0x86, 0xd7, 0xbd, 0xe9, + 0x21, 0xf8, 0x27, 0x04, 0x5b, 0x13, 0xe5, 0x69, 0x70, 0x22, 0xc4, 0x88, 0x38, 0xc4, 0x15, 0x06, + 0xb7, 0x86, 0xc4, 0x0e, 0x46, 0xc4, 0xd6, 0x96, 0xa5, 0x98, 0x07, 0x97, 0x29, 0xd9, 0x5e, 0x82, + 0x93, 0x39, 0x8c, 0x4d, 0x7b, 0x6a, 0x54, 0x2f, 0x26, 0xc3, 0xf7, 0x41, 0xa3, 0xdc, 0x90, 0xb5, + 0x1d, 0xb3, 0x18, 0xc4, 0x35, 0xfb, 0xa1, 0x90, 0xca, 0x06, 0xda, 0x2e, 0xea, 0xab, 0x94, 0x87, + 0x85, 0xdc, 0x51, 0xab, 0x9d, 0x68, 0x11, 0x77, 0xa0, 0x4e, 0xb9, 0x91, 0x52, 0xf0, 0xc9, 0xfc, + 0xeb, 0x32, 0xbf, 0x4a, 0x79, 0x2a, 0x97, 0x8f, 0xc3, 0x7c, 0x83, 0xa0, 0x3e, 0xa2, 0x5f, 0x04, + 0xd4, 0xa6, 0xe2, 0xc4, 0x70, 0xa8, 0x1b, 0x5e, 0x4a, 0x5c, 0x0a, 0x1e, 0xa3, 0xae, 0xe0, 0xda, + 0x8d, 0xd9, 0xef, 0x71, 0x3f, 0x86, 0x78, 0x24, 0x11, 0xde, 0x8f, 0x00, 0x0e, 0x64, 0x7e, 0xfc, + 0x1e, 0x47, 0x39, 0x31, 0xf8, 0x4b, 0x78, 0xdd, 0x0a, 0x7c, 0x3f, 0xbc, 0x89, 0x09, 0x39, 0x96, + 0xe9, 0x78, 0x26, 0x1d, 0xb8, 0xda, 0xff, 0x64, 0x97, 0xbf, 0x77, 0x09, 0x21, 0x1f, 0xa8, 0x54, + 0xbd, 0xa6, 0xd0, 0xa7, 0xac, 0xe3, 0xaf, 0x10, 0x34, 0x02, 0xcf, 0x62, 0x4e, 0x48, 0x38, 0x5d, + 0xc1, 0xcd, 0x7f, 0xaf, 0xa0, 0x1e, 0xc3, 0x4f, 0x09, 0x68, 0xfc, 0x8c, 0xa0, 0x72, 0xae, 0x65, + 0xe3, 0x75, 0x28, 0xc5, 0xa5, 0x69, 0x4b, 0x8b, 0x2b, 0xe9, 0xc5, 0x68, 0xa2, 0x6b, 0xe3, 0x2a, + 0x94, 0x28, 0x6f, 0x07, 0x27, 0x3d, 0x6a, 0x13, 0x6d, 0x41, 0x5e, 0x75, 0x3a, 0x81, 0xdb, 0xb0, + 0x28, 0xbb, 0x79, 0xec, 0x40, 0x6f, 0xce, 0x32, 0x8a, 0x7d, 0xea, 0xd0, 0x88, 0x5a, 0x57, 0x99, + 0x0f, 0x8a, 0xcf, 0x9e, 0xd7, 0x0b, 0x7f, 0x3f, 0xaf, 0x17, 0x1a, 0xbf, 0x22, 0xb8, 0x75, 0x41, + 0xbf, 0xff, 0x2f, 0x02, 0x3f, 0x1a, 0x13, 0xf8, 0xce, 0x7c, 0xf5, 0x96, 0x2b, 0xf3, 0x7b, 0x04, + 0x4b, 0xca, 0x38, 0xf0, 0x26, 0x54, 0x32, 0x4d, 0x3d, 0x91, 0xb7, 0x9c, 0x4e, 0x76, 0x6d, 0xbc, + 0x02, 0xd7, 0x6c, 0xe2, 0x32, 0x47, 0xca, 0x2b, 0xe9, 0xd1, 0x07, 0x7e, 0x0f, 0x8a, 0x36, 0x91, + 0xf6, 0x10, 0x8a, 0x43, 0xb3, 0xac, 0x6a, 0x37, 0x8a, 0xd5, 0x93, 0xa4, 0x8c, 0xa2, 0x5f, 0x10, + 0xe0, 0x49, 0x0b, 0x9a, 0x4f, 0xdc, 0xb9, 0xc3, 0x5d, 0x18, 0x3b, 0xdc, 0x87, 0x50, 0x8c, 0x0d, + 0x4c, 0x69, 0x7c, 0x23, 0xb7, 0x7b, 0xaa, 0x58, 0x3d, 0xc9, 0xca, 0x88, 0xfc, 0x0d, 0xc1, 0x8d, + 0x31, 0x17, 0x9b, 0x4f, 0xe1, 0x08, 0xfe, 0x7f, 0xb1, 0x71, 0x4a, 0xb9, 0x33, 0xee, 0xb4, 0x77, + 0x81, 0x41, 0xaa, 0x56, 0xb1, 0x72, 0x91, 0x79, 0x66, 0x04, 0xff, 0x88, 0xa0, 0x9a, 0xe7, 0x80, + 0xf9, 0xef, 0xf2, 0x09, 0x94, 0xb3, 0x86, 0xb7, 0x30, 0xbb, 0xa4, 0xa7, 0x70, 0xe9, 0xe0, 0x24, + 0xe3, 0xc6, 0x33, 0x04, 0xeb, 0x39, 0x1e, 0x95, 0x2f, 0x69, 0x1f, 0x96, 0x94, 0x21, 0x2a, 0x39, + 0x3b, 0x97, 0xb7, 0x42, 0x3d, 0x86, 0x68, 0x7c, 0x87, 0xa0, 0x9a, 0xd7, 0x90, 0xb1, 0x06, 0x4b, + 0xea, 0x78, 0x95, 0x92, 0xf8, 0x13, 0xef, 0xc1, 0xa2, 0x6a, 0xfa, 0xf2, 0xc1, 0xb5, 0x9b, 0xe1, + 0x7d, 0xfc, 0xf1, 0xaa, 0xbe, 0x35, 0xa0, 0x62, 0x18, 0xf4, 0x9b, 0x16, 0x73, 0x5a, 0x16, 0xe3, + 0x0e, 0xe3, 0xea, 0xe7, 0x0e, 0xb7, 0x8f, 0x5a, 0xe2, 0xc4, 0x23, 0xbc, 0xb9, 0x4b, 0x2c, 0x5d, + 0x65, 0xa7, 0x77, 0xd5, 0x1e, 0xbe, 0x38, 0xad, 0xa1, 0x97, 0xa7, 0x35, 0xf4, 0xd7, 0x69, 0x0d, + 0xfd, 0x70, 0x56, 0x2b, 0xbc, 0x3c, 0xab, 0x15, 0x7e, 0x3f, 0xab, 0x15, 0x3e, 0x7d, 0x9c, 0xc1, + 0xec, 0xc6, 0xbb, 0xdd, 0x37, 0xfb, 0xbc, 0x95, 0xec, 0xfd, 0x8e, 0xc5, 0x7c, 0x92, 0xfd, 0x1c, + 0x9a, 0xd4, 0x6d, 0x39, 0x2c, 0xf4, 0x4e, 0x9e, 0xfe, 0x8b, 0x90, 0xfc, 0xfd, 0x45, 0xf9, 0x2f, + 0xe1, 0xde, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xb4, 0x7d, 0x58, 0x0d, 0xae, 0x0c, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { @@ -580,6 +653,48 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.UpcomingLiquidityMiningCampaign != nil { + { + size, err := m.UpcomingLiquidityMiningCampaign.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } + if m.CurrentLiquidityMiningCampaign != nil { + { + size, err := m.CurrentLiquidityMiningCampaign.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + if len(m.LiquidityMiningAccountPoints) > 0 { + for iNdEx := len(m.LiquidityMiningAccountPoints) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.LiquidityMiningAccountPoints[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x7a + } + } if m.IsDerivativesExchangeEnabled { i-- if m.IsDerivativesExchangeEnabled { @@ -1097,6 +1212,46 @@ func (m *PerpetualMarketFundingState) MarshalToSizedBuffer(dAtA []byte) (int, er return len(dAtA) - i, nil } +func (m *LiquidityMiningAccountPoints) 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 *LiquidityMiningAccountPoints) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LiquidityMiningAccountPoints) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.Points.Size() + i -= size + if _, err := m.Points.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.Account) > 0 { + i -= len(m.Account) + copy(dAtA[i:], m.Account) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.Account))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { offset -= sovGenesis(v) base := offset @@ -1188,6 +1343,20 @@ func (m *GenesisState) Size() (n int) { if m.IsDerivativesExchangeEnabled { n += 2 } + if len(m.LiquidityMiningAccountPoints) > 0 { + for _, e := range m.LiquidityMiningAccountPoints { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + if m.CurrentLiquidityMiningCampaign != nil { + l = m.CurrentLiquidityMiningCampaign.Size() + n += 2 + l + sovGenesis(uint64(l)) + } + if m.UpcomingLiquidityMiningCampaign != nil { + l = m.UpcomingLiquidityMiningCampaign.Size() + n += 2 + l + sovGenesis(uint64(l)) + } return n } @@ -1326,6 +1495,21 @@ func (m *PerpetualMarketFundingState) Size() (n int) { return n } +func (m *LiquidityMiningAccountPoints) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Account) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + l = m.Points.Size() + n += 1 + l + sovGenesis(uint64(l)) + return n +} + func sovGenesis(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -1808,6 +1992,112 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { } } m.IsDerivativesExchangeEnabled = bool(v != 0) + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LiquidityMiningAccountPoints", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LiquidityMiningAccountPoints = append(m.LiquidityMiningAccountPoints, LiquidityMiningAccountPoints{}) + if err := m.LiquidityMiningAccountPoints[len(m.LiquidityMiningAccountPoints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentLiquidityMiningCampaign", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CurrentLiquidityMiningCampaign == nil { + m.CurrentLiquidityMiningCampaign = &LiquidityMiningCampaign{} + } + if err := m.CurrentLiquidityMiningCampaign.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UpcomingLiquidityMiningCampaign", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.UpcomingLiquidityMiningCampaign == nil { + m.UpcomingLiquidityMiningCampaign = &LiquidityMiningCampaign{} + } + if err := m.UpcomingLiquidityMiningCampaign.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenesis(dAtA[iNdEx:]) @@ -2752,6 +3042,122 @@ func (m *PerpetualMarketFundingState) Unmarshal(dAtA []byte) error { } return nil } +func (m *LiquidityMiningAccountPoints) 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 ErrIntOverflowGenesis + } + 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: LiquidityMiningAccountPoints: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LiquidityMiningAccountPoints: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + 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 ErrInvalidLengthGenesis + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Account = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Points", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + 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 ErrInvalidLengthGenesis + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Points.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipGenesis(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/chain/exchange/types/key.go b/chain/exchange/types/key.go index 9c23c2b9..07c1c0aa 100644 --- a/chain/exchange/types/key.go +++ b/chain/exchange/types/key.go @@ -53,6 +53,12 @@ var ( PerpetualMarketInfoPrefix = []byte{0x32} // prefix for each key to a perpetual market's market info ExpiryFuturesMarketInfoPrefix = []byte{0x33} // prefix for each key to a expiry futures market's market info ExpiryFuturesMarketInfoByTimestampPrefix = []byte{0x34} // prefix for each index key to a expiry futures market's market info + + LiquidityMiningMarketRewardsRateKey = []byte{0x40} // prefix for each key to a market's liquidity mining reward rate + LiquidityMiningAccountPointsKey = []byte{0x41} // prefix for each key to an account's liquidity mining points + CurrentLiquidityMiningCampaignKey = []byte{0x42} // key to the current liquidity mining campaign + UpcomingLiquidityMiningCampaignKey = []byte{0x43} // key to the upcoming liquidity mining campaign + TotalLiquidityMiningPointsKey = []byte{0x44} // key to the total liquidity mining points ) // GetDepositKey provides the key to obtain a given subaccount's deposits for a given denom @@ -159,6 +165,10 @@ func GetDerivativeMarketKey(isEnabled bool) []byte { return append(DerivativeMarketPrefix, getBoolPrefix(isEnabled)...) } +func GetAccountLiquidityMiningPointsKey(account sdk.AccAddress) []byte { + return append(LiquidityMiningAccountPointsKey, account.Bytes()...) +} + func getBoolPrefix(isEnabled bool) []byte { isEnabledByte := byte(0) if isEnabled { diff --git a/chain/exchange/types/liquidity_mining_rewards.go b/chain/exchange/types/liquidity_mining_rewards.go new file mode 100644 index 00000000..0b0e1478 --- /dev/null +++ b/chain/exchange/types/liquidity_mining_rewards.go @@ -0,0 +1,64 @@ +package types + +import ( + "sort" + + sdk "github.com/cosmos/cosmos-sdk/types" +) + +type LiquidityMiningRewards map[string]sdk.Dec + +func NewLiquidityMiningRewards() LiquidityMiningRewards { + liquidityMiningRewards := make(LiquidityMiningRewards) + + return liquidityMiningRewards +} + +func (l LiquidityMiningRewards) GetSortedAccountKeys() []string { + accountKeys := make([]string, 0, len(l)) + for k := range l { + accountKeys = append(accountKeys, k) + } + sort.Strings(accountKeys) + return accountKeys +} + +func (l LiquidityMiningRewards) AddPointsForAddress(addr string, newPoints sdk.Dec) { + v, found := l[addr] + if !found { + l[addr] = newPoints + } else { + l[addr] = v.Add(newPoints) + } +} + +func (l *LiquidityMiningRewards) GetAllAccountAddresses() []string { + accountAddresses := make([]string, 0) + + for k := range *l { + accountAddresses = append(accountAddresses, k) + } + + return accountAddresses +} + +func MergeLiquidityMiningRewards(m1, m2 LiquidityMiningRewards) LiquidityMiningRewards { + if m1 == nil || len(m1) == 0 { + return m2 + } else if m2 == nil || len(m2) == 0 { + return m1 + } + + if len(m1) >= len(m2) { + for k, v := range m2 { + m1.AddPointsForAddress(k, v) + } + return m1 + } else { + for k, v := range m1 { + m2.AddPointsForAddress(k, v) + } + return m2 + } + +} diff --git a/chain/exchange/types/market_ids.go b/chain/exchange/types/market_ids.go index 2ea136f6..00160fae 100644 --- a/chain/exchange/types/market_ids.go +++ b/chain/exchange/types/market_ids.go @@ -47,4 +47,4 @@ func NewDerivativesMarketID(ticker, quoteDenom, oracleBase, oracleQuote string, } else { return NewExpiryFuturesMarketID(ticker, quoteDenom, oracleBase, oracleQuote, oracleType, expiry) } -} \ No newline at end of file +} diff --git a/chain/exchange/types/params.go b/chain/exchange/types/params.go index 0d2971b6..e94b707b 100644 --- a/chain/exchange/types/params.go +++ b/chain/exchange/types/params.go @@ -256,18 +256,20 @@ func ValidateHourlyFundingRateCap(i interface{}) error { } if v.IsNil() { - return fmt.Errorf("hourly interest rate cannot be nil: %s", v) + return fmt.Errorf("hourly funding rate cap cannot be nil: %s", v) } if v.IsNegative() { - return fmt.Errorf("hourly interest rate cannot be negative: %s", v) + return fmt.Errorf("hourly funding rate cap cannot be negative: %s", v) } if v.IsZero() { - return fmt.Errorf("hourly interest rate cannot be zero: %s", v) + return fmt.Errorf("hourly funding rate cap cannot be zero: %s", v) } - // TODO validate more ? + if v.GT(sdk.NewDecWithPrec(3, 2)) { + return fmt.Errorf("hourly funding rate cap cannot be larger than 3 percent: %s", v) + } return nil } @@ -287,12 +289,10 @@ func ValidateHourlyInterestRate(i interface{}) error { return fmt.Errorf("hourly interest rate cannot be negative: %s", v) } - if v.IsZero() { - return fmt.Errorf("hourly interest rate cannot be zero: %s", v) + if v.GT(sdk.NewDecWithPrec(1, 2)) { + return fmt.Errorf("hourly interest rate cannot be larger than 1 percent: %s", v) } - // TODO validate more ? - return nil } diff --git a/chain/exchange/types/proposal.go b/chain/exchange/types/proposal.go index 8a6a5ef3..72068050 100644 --- a/chain/exchange/types/proposal.go +++ b/chain/exchange/types/proposal.go @@ -19,6 +19,7 @@ const ( ProposalTypeExpiryFuturesMarketLaunch string = "ProposalTypeExpiryFuturesMarketLaunch" ProposalTypeDerivativeMarketParamUpdate string = "ProposalTypeDerivativeMarketParamUpdate" ProposalTypeDerivativeMarketBandOraclePromotion string = "ProposalTypeDerivativeMarketBandOraclePromotion" + ProposalTypeLiquidityMiningCampaign string = "ProposalTypeLiquidityMiningCampaign" ) func init() { @@ -36,6 +37,8 @@ func init() { gov.RegisterProposalTypeCodec(&DerivativeMarketParamUpdateProposal{}, "injective/DerivativeMarketParamUpdateProposal") gov.RegisterProposalType(ProposalTypeDerivativeMarketBandOraclePromotion) gov.RegisterProposalTypeCodec(&DerivativeMarketBandOraclePromotionProposal{}, "injective/DerivativeMarketBandOraclePromotionProposal") + gov.RegisterProposalType(ProposalTypeLiquidityMiningCampaign) + gov.RegisterProposalTypeCodec(&LiquidityMiningCampaignProposal{}, "injective/LiquidityMiningCampaignProposal") } // Implements Proposal Interface @@ -586,3 +589,133 @@ func (p *DerivativeMarketBandOraclePromotionProposal) ValidateBasic() error { return gov.ValidateAbstract(p) } + +// NewLiquidityMiningCampaignProposal returns new instance of LiquidityMiningCampaignProposal +func NewLiquidityMiningCampaignProposal( + title, description string, + spotMarketIDs []string, + spotMarketWeights []sdk.Dec, + derivativeMarketIDs []string, + derivativeMarketWeights []sdk.Dec, + maxEpochRewards sdk.Coins, +) *LiquidityMiningCampaignProposal { + p := &LiquidityMiningCampaignProposal{ + Title: title, + Description: description, + Campaign: &LiquidityMiningCampaign{ + SpotMarketIds: spotMarketIDs, + SpotMarketWeights: spotMarketWeights, + DerivativeMarketIds: derivativeMarketIDs, + DerivativeMarketWeights: derivativeMarketWeights, + MaxEpochRewards: maxEpochRewards, + }, + } + if err := p.ValidateBasic(); err != nil { + panic(err) + } + return p +} + +// Implements Proposal Interface +var _ gov.Content = &LiquidityMiningCampaignProposal{} + +// GetTitle returns the title of this proposal +func (p *LiquidityMiningCampaignProposal) GetTitle() string { + return p.Title +} + +// GetDescription returns the description of this proposal +func (p *LiquidityMiningCampaignProposal) GetDescription() string { + return p.Description +} + +// ProposalRoute returns router key of this proposal. +func (p *LiquidityMiningCampaignProposal) ProposalRoute() string { return RouterKey } + +// ProposalType returns proposal type of this proposal. +func (p *LiquidityMiningCampaignProposal) ProposalType() string { + return ProposalTypeLiquidityMiningCampaign +} + +// ValidateBasic returns ValidateBasic result of this proposal. +func (p *LiquidityMiningCampaignProposal) ValidateBasic() error { + if p.Campaign == nil { + return ErrInvalidLiquidityMiningCampaign + } + + isEndingCampaign := len(p.Campaign.MaxEpochRewards) == 0 + hasOtherNonEmptyFields := len(p.Campaign.SpotMarketIds) != 0 || len(p.Campaign.SpotMarketWeights) != 0 || + len(p.Campaign.DerivativeMarketIds) != 0 || len(p.Campaign.DerivativeMarketWeights) != 0 + + if isEndingCampaign && hasOtherNonEmptyFields { + return ErrInvalidLiquidityMiningCampaign + } + + if isEndingCampaign { + return nil + } + + if len(p.Campaign.SpotMarketWeights) != len(p.Campaign.SpotMarketIds) { + return ErrInvalidLiquidityMiningMarket + } + + if len(p.Campaign.DerivativeMarketWeights) != len(p.Campaign.DerivativeMarketIds) { + return ErrInvalidLiquidityMiningMarket + } + + if len(p.Campaign.SpotMarketIds) == 0 && len(p.Campaign.DerivativeMarketIds) == 0 { + return ErrInvalidLiquidityMiningMarket + } + + hasDuplicatesInMarkets := HasDuplicates(p.Campaign.SpotMarketIds) || HasDuplicates(p.Campaign.DerivativeMarketIds) + + if hasDuplicatesInMarkets { + return ErrInvalidLiquidityMiningMarket + } + + totalWeight := sdk.ZeroDec() + + for idx, weight := range p.Campaign.SpotMarketWeights { + if weight.IsNil() || !weight.IsPositive() { + return ErrInvalidLiquidityMiningMarketWeights + } + + if p.Campaign.SpotMarketIds[idx] == "" { + return ErrInvalidLiquidityMiningMarket + } + totalWeight = totalWeight.Add(weight) + } + + for idx, weight := range p.Campaign.DerivativeMarketWeights { + if weight.IsNil() || weight.IsNegative() { + return ErrInvalidLiquidityMiningMarketWeights + } + if p.Campaign.DerivativeMarketIds[idx] == "" { + return ErrInvalidLiquidityMiningMarket + } + totalWeight = totalWeight.Add(weight) + } + + // sum of weights must equal 1 + if !totalWeight.Equal(sdk.OneDec()) { + return ErrInvalidLiquidityMiningMarketWeights + } + + hasDuplicatesInEpochRewards := HasDuplicatesCoin(p.Campaign.MaxEpochRewards) + + if hasDuplicatesInEpochRewards { + return ErrInvalidLiquidityMiningReward + } + + for _, epochRewardDenom := range p.Campaign.MaxEpochRewards { + if !epochRewardDenom.IsValid() { + return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, epochRewardDenom.String()) + } + + if epochRewardDenom.Amount.IsZero() { + return ErrInvalidLiquidityMiningReward + } + } + + return gov.ValidateAbstract(p) +} diff --git a/chain/exchange/types/query.pb.go b/chain/exchange/types/query.pb.go index c455e72d..2a6c1ff4 100644 --- a/chain/exchange/types/query.pb.go +++ b/chain/exchange/types/query.pb.go @@ -1734,6 +1734,43 @@ func (m *QueryPositionsRequest) XXX_DiscardUnknown() { var xxx_messageInfo_QueryPositionsRequest proto.InternalMessageInfo +// QueryLiquidityMiningPointsRequest is the request type for the Query/LiquidityMiningPoints RPC method. +type QueryLiquidityMiningPointsRequest struct { +} + +func (m *QueryLiquidityMiningPointsRequest) Reset() { *m = QueryLiquidityMiningPointsRequest{} } +func (m *QueryLiquidityMiningPointsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryLiquidityMiningPointsRequest) ProtoMessage() {} +func (*QueryLiquidityMiningPointsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_523db28b8af54781, []int{35} +} +func (m *QueryLiquidityMiningPointsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryLiquidityMiningPointsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryLiquidityMiningPointsRequest.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 *QueryLiquidityMiningPointsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryLiquidityMiningPointsRequest.Merge(m, src) +} +func (m *QueryLiquidityMiningPointsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryLiquidityMiningPointsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryLiquidityMiningPointsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryLiquidityMiningPointsRequest proto.InternalMessageInfo + // QueryPositionsResponse is the response type for the Query/Positions RPC method. type QueryPositionsResponse struct { State []DerivativePosition `protobuf:"bytes,1,rep,name=state,proto3" json:"state"` @@ -1743,7 +1780,7 @@ func (m *QueryPositionsResponse) Reset() { *m = QueryPositionsResponse{} func (m *QueryPositionsResponse) String() string { return proto.CompactTextString(m) } func (*QueryPositionsResponse) ProtoMessage() {} func (*QueryPositionsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_523db28b8af54781, []int{35} + return fileDescriptor_523db28b8af54781, []int{36} } func (m *QueryPositionsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1779,6 +1816,44 @@ func (m *QueryPositionsResponse) GetState() []DerivativePosition { return nil } +// QueryLiquidityMiningPointsResponse is the response type for the Query/LiquidityMiningPoints RPC method. +type QueryLiquidityMiningPointsResponse struct { + TotalLiquidityMiningPoints github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=total_liquidity_mining_points,json=totalLiquidityMiningPoints,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"total_liquidity_mining_points"` +} + +func (m *QueryLiquidityMiningPointsResponse) Reset() { *m = QueryLiquidityMiningPointsResponse{} } +func (m *QueryLiquidityMiningPointsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryLiquidityMiningPointsResponse) ProtoMessage() {} +func (*QueryLiquidityMiningPointsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_523db28b8af54781, []int{37} +} +func (m *QueryLiquidityMiningPointsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryLiquidityMiningPointsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryLiquidityMiningPointsResponse.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 *QueryLiquidityMiningPointsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryLiquidityMiningPointsResponse.Merge(m, src) +} +func (m *QueryLiquidityMiningPointsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryLiquidityMiningPointsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryLiquidityMiningPointsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryLiquidityMiningPointsResponse proto.InternalMessageInfo + func init() { proto.RegisterType((*Subaccount)(nil), "injective.exchange.v1beta1.Subaccount") proto.RegisterType((*QueryExchangeParamsRequest)(nil), "injective.exchange.v1beta1.QueryExchangeParamsRequest") @@ -1816,7 +1891,9 @@ func init() { proto.RegisterType((*QueryModuleStateRequest)(nil), "injective.exchange.v1beta1.QueryModuleStateRequest") proto.RegisterType((*QueryModuleStateResponse)(nil), "injective.exchange.v1beta1.QueryModuleStateResponse") proto.RegisterType((*QueryPositionsRequest)(nil), "injective.exchange.v1beta1.QueryPositionsRequest") + proto.RegisterType((*QueryLiquidityMiningPointsRequest)(nil), "injective.exchange.v1beta1.QueryLiquidityMiningPointsRequest") proto.RegisterType((*QueryPositionsResponse)(nil), "injective.exchange.v1beta1.QueryPositionsResponse") + proto.RegisterType((*QueryLiquidityMiningPointsResponse)(nil), "injective.exchange.v1beta1.QueryLiquidityMiningPointsResponse") } func init() { @@ -1824,117 +1901,122 @@ func init() { } var fileDescriptor_523db28b8af54781 = []byte{ - // 1752 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xdf, 0x6f, 0x13, 0xc7, - 0x16, 0xce, 0x38, 0xb1, 0x6f, 0x72, 0x42, 0x20, 0x0c, 0x21, 0x04, 0x03, 0x26, 0x77, 0xd0, 0xe5, - 0x06, 0x04, 0x36, 0x71, 0x20, 0xbf, 0x08, 0xe1, 0x2a, 0x37, 0x09, 0x09, 0x04, 0x08, 0x0b, 0x57, - 0xba, 0xa0, 0x4a, 0x61, 0x6d, 0x4f, 0x9c, 0x25, 0xeb, 0x5d, 0xb3, 0xbb, 0x8e, 0xb0, 0x10, 0x2f, - 0xfd, 0x0b, 0x2a, 0xf1, 0x5e, 0xa9, 0xaf, 0x3c, 0xf4, 0xa1, 0x7d, 0xeb, 0x43, 0x2b, 0xf1, 0x50, - 0xa1, 0x56, 0xaa, 0xa8, 0x5a, 0x55, 0x55, 0x1f, 0x50, 0x05, 0x7d, 0xa8, 0xaa, 0xfe, 0x01, 0x7d, - 0xac, 0x76, 0x66, 0x76, 0xd7, 0x5e, 0x7b, 0x37, 0xbb, 0x2e, 0x0f, 0xf4, 0x89, 0xec, 0x78, 0xce, - 0x37, 0xdf, 0x77, 0xe6, 0x9c, 0x99, 0x73, 0x06, 0x38, 0xa9, 0x68, 0x0f, 0x68, 0xd1, 0x52, 0x76, - 0x68, 0x8e, 0x3e, 0x2a, 0x6e, 0xc9, 0x5a, 0x99, 0xe6, 0x76, 0xc6, 0x0b, 0xd4, 0x92, 0xc7, 0x73, - 0x0f, 0x6b, 0xd4, 0xa8, 0x67, 0xab, 0x86, 0x6e, 0xe9, 0x38, 0xed, 0xce, 0xcb, 0x3a, 0xf3, 0xb2, - 0x62, 0x5e, 0xfa, 0x68, 0x59, 0xd7, 0xcb, 0x2a, 0xcd, 0xc9, 0x55, 0x25, 0x27, 0x6b, 0x9a, 0x6e, - 0xc9, 0x96, 0xa2, 0x6b, 0x26, 0xb7, 0x4c, 0x9f, 0x0a, 0x59, 0xc1, 0x85, 0xe2, 0x53, 0xc7, 0x42, - 0xa6, 0x96, 0xa9, 0x46, 0x4d, 0xc5, 0x01, 0x1d, 0x2a, 0xeb, 0x65, 0x9d, 0xfd, 0x99, 0xb3, 0xff, - 0xe2, 0xa3, 0xe4, 0x26, 0xc0, 0xed, 0x5a, 0x41, 0x2e, 0x16, 0xf5, 0x9a, 0x66, 0xe1, 0x61, 0x48, - 0x59, 0x86, 0x5c, 0xa2, 0xc6, 0x08, 0x1a, 0x45, 0x63, 0x7d, 0x92, 0xf8, 0xc2, 0xa7, 0x60, 0xd0, - 0x74, 0x67, 0x6d, 0x68, 0xba, 0x56, 0xa4, 0x23, 0x89, 0x51, 0x34, 0x36, 0x20, 0xed, 0xf3, 0xc6, - 0x6f, 0xd8, 0xc3, 0xe4, 0x28, 0xa4, 0x6f, 0xd9, 0x4e, 0x58, 0x12, 0x6c, 0xd6, 0x65, 0x43, 0xae, - 0x98, 0x12, 0x7d, 0x58, 0xa3, 0xa6, 0x45, 0x36, 0xe0, 0x48, 0xdb, 0x5f, 0xcd, 0xaa, 0xae, 0x99, - 0x14, 0xff, 0x07, 0x52, 0x55, 0x36, 0xc2, 0xd6, 0xef, 0xcf, 0x93, 0x6c, 0xb0, 0x0f, 0xb3, 0xdc, - 0x76, 0xa1, 0xe7, 0xc5, 0xab, 0xe3, 0x5d, 0x92, 0xb0, 0x23, 0x4f, 0x11, 0x64, 0xd8, 0x0a, 0x9e, - 0xaa, 0x45, 0x5a, 0xd5, 0x4d, 0xc5, 0x72, 0x38, 0xe0, 0x13, 0x30, 0xd0, 0x20, 0x46, 0x29, 0x09, - 0xad, 0x7b, 0xbc, 0xc1, 0xd5, 0x12, 0x5e, 0x03, 0xf0, 0xbe, 0x99, 0xd6, 0xfe, 0xfc, 0xc9, 0x30, - 0x36, 0xde, 0x7a, 0x8c, 0x11, 0x92, 0x1a, 0xec, 0xc9, 0x6f, 0x08, 0x8e, 0x07, 0xb2, 0x12, 0xda, - 0x29, 0xf4, 0x96, 0xc4, 0xd8, 0x08, 0x1a, 0xed, 0x1e, 0xeb, 0xcf, 0xaf, 0x86, 0xad, 0xb7, 0x0b, - 0x5c, 0xd6, 0x19, 0x58, 0xd2, 0x2c, 0xa3, 0x2e, 0xb9, 0xd0, 0xe9, 0xfb, 0x30, 0xd0, 0xf4, 0x13, - 0x1e, 0x84, 0xee, 0x6d, 0x5a, 0x17, 0x4e, 0xb0, 0xff, 0xc4, 0x33, 0x90, 0xdc, 0x91, 0xd5, 0x1a, - 0x15, 0xb2, 0x4f, 0x84, 0xd1, 0x10, 0x58, 0x12, 0xb7, 0x98, 0x4d, 0x4c, 0x23, 0x92, 0x81, 0xa3, - 0x4d, 0x7b, 0xbc, 0x20, 0xab, 0xb2, 0x56, 0xa4, 0x6e, 0x0c, 0x6c, 0xc2, 0xb1, 0x80, 0xdf, 0x85, - 0x27, 0x96, 0xa0, 0xb7, 0x20, 0xc6, 0x84, 0x27, 0x42, 0x29, 0x08, 0x7b, 0x11, 0x08, 0xae, 0x29, - 0xb9, 0x27, 0xd6, 0x69, 0x71, 0x52, 0xac, 0x40, 0x18, 0x82, 0x64, 0x89, 0x6a, 0x7a, 0x85, 0x39, - 0xa3, 0x4f, 0xe2, 0x1f, 0x44, 0x0e, 0x8a, 0x32, 0x57, 0xc4, 0xe5, 0xa6, 0xed, 0x8c, 0xec, 0x47, - 0xd7, 0x88, 0x8c, 0xc3, 0x21, 0xbe, 0x44, 0x55, 0xb7, 0xae, 0xcb, 0xc6, 0x36, 0xf5, 0x22, 0x78, - 0x18, 0x52, 0xa6, 0x25, 0x5b, 0x35, 0xd3, 0x49, 0x53, 0xfe, 0x45, 0xde, 0x83, 0x91, 0x56, 0x13, - 0x37, 0xb5, 0xfe, 0x51, 0xe1, 0x43, 0xc2, 0xa7, 0xe1, 0xd1, 0xec, 0x22, 0x48, 0x8e, 0x19, 0xb9, - 0x00, 0xc3, 0x3e, 0x74, 0x87, 0xcf, 0x11, 0xe8, 0xe3, 0x93, 0x3c, 0x27, 0xf6, 0xf2, 0x81, 0xd5, - 0x12, 0xb9, 0xdb, 0xa2, 0xc3, 0xe5, 0x34, 0x0f, 0x29, 0x3e, 0x4d, 0x78, 0x28, 0x2a, 0x25, 0x61, - 0x45, 0x6e, 0xc0, 0x61, 0x17, 0xfa, 0xa6, 0x51, 0xa2, 0x46, 0x41, 0xd7, 0xb7, 0xa3, 0x90, 0xb2, - 0x77, 0x55, 0x55, 0x2a, 0x0a, 0xcf, 0xec, 0x1e, 0x89, 0x7f, 0x90, 0xe7, 0x48, 0x1c, 0x5e, 0x3e, - 0x40, 0x41, 0x77, 0x1d, 0x06, 0x0b, 0xb5, 0xba, 0xb9, 0x51, 0x35, 0x94, 0x22, 0xdd, 0x50, 0xe9, - 0x0e, 0x55, 0xa3, 0xf8, 0x72, 0xdd, 0x9e, 0xbe, 0x66, 0xcf, 0x96, 0xf6, 0xda, 0xf6, 0xde, 0x37, - 0x96, 0x60, 0xbf, 0x49, 0x55, 0xb5, 0x19, 0x32, 0x11, 0x0b, 0x72, 0x1f, 0x03, 0xf0, 0x06, 0xc8, - 0x7d, 0x91, 0x7e, 0x77, 0xd8, 0xd1, 0xed, 0x2a, 0x31, 0x23, 0xf9, 0xa5, 0x25, 0x25, 0x12, 0xad, - 0x29, 0x41, 0x9e, 0x25, 0xe0, 0xe0, 0x1d, 0x43, 0xa9, 0x54, 0x68, 0xc9, 0x86, 0x5f, 0xb3, 0x7d, - 0xc7, 0xd6, 0xc0, 0x8b, 0x90, 0x64, 0x4a, 0x38, 0xee, 0x42, 0xd6, 0xce, 0xc8, 0x9f, 0x5e, 0x1d, - 0x3f, 0x59, 0x56, 0xac, 0xad, 0x5a, 0x21, 0x5b, 0xd4, 0x2b, 0xb9, 0xa2, 0x6e, 0x56, 0x74, 0x53, - 0xfc, 0x73, 0xd6, 0x2c, 0x6d, 0xe7, 0xac, 0x7a, 0x95, 0x9a, 0xd9, 0x45, 0x5a, 0x94, 0xb8, 0x31, - 0xbe, 0x0a, 0xbd, 0x0f, 0x6b, 0xb2, 0x66, 0x29, 0x56, 0x9d, 0xaf, 0x1f, 0x1b, 0xc8, 0xb5, 0xb7, - 0xb1, 0x36, 0x15, 0x55, 0x95, 0x0b, 0x2a, 0x1d, 0xe9, 0xee, 0x0c, 0xcb, 0xb1, 0xb7, 0x83, 0x46, - 0x31, 0x17, 0x6a, 0xf5, 0x91, 0x9e, 0x51, 0x34, 0xd6, 0x2b, 0xf1, 0x0f, 0x7c, 0x0c, 0x40, 0xb7, - 0xc5, 0x6f, 0x6c, 0xc9, 0xe6, 0xd6, 0x48, 0x92, 0xf9, 0xab, 0x8f, 0x8d, 0xac, 0xc8, 0xe6, 0x16, - 0x79, 0x20, 0x4e, 0xa1, 0xd6, 0xed, 0x10, 0x51, 0xb5, 0x0a, 0x29, 0x36, 0xdb, 0xc9, 0xcb, 0xf1, - 0xb0, 0x8d, 0x6f, 0xeb, 0x76, 0x49, 0x00, 0x90, 0x3b, 0xe2, 0x96, 0x59, 0xa4, 0x86, 0xb2, 0x23, - 0xdb, 0x08, 0x6f, 0x23, 0x2b, 0x5e, 0x20, 0x18, 0x0d, 0x86, 0xfd, 0x5b, 0xe5, 0xc6, 0x26, 0x90, - 0x86, 0xcd, 0xf0, 0xe9, 0x79, 0x8b, 0x19, 0xf2, 0x47, 0x02, 0x8e, 0x88, 0xad, 0xf2, 0x16, 0x79, - 0xa7, 0xf3, 0x64, 0x99, 0x1d, 0xc5, 0x65, 0x45, 0xeb, 0x30, 0x4b, 0x84, 0x75, 0x53, 0xbe, 0xf5, - 0xbc, 0xad, 0x7c, 0x4b, 0x06, 0xe7, 0x5b, 0xca, 0x9f, 0x6f, 0x3b, 0x70, 0x22, 0x74, 0x8b, 0x45, - 0xbc, 0xde, 0xf4, 0x65, 0xdd, 0x54, 0x84, 0xac, 0x6b, 0xb7, 0x95, 0x6e, 0xee, 0x4d, 0x89, 0x3c, - 0xf7, 0x26, 0x45, 0xbc, 0xb4, 0x3f, 0x44, 0x00, 0x0d, 0x61, 0xff, 0xce, 0x85, 0x06, 0xf9, 0x02, - 0xc1, 0xd0, 0x3a, 0x35, 0xaa, 0xd4, 0xaa, 0xc9, 0x2a, 0x17, 0x75, 0xdb, 0x92, 0x2d, 0x3b, 0xe7, - 0xfb, 0x9d, 0x3c, 0xd1, 0x36, 0x75, 0x71, 0x87, 0xe7, 0x42, 0x73, 0xb3, 0x19, 0x66, 0x55, 0xdb, - 0xd4, 0x25, 0xa8, 0xb8, 0x7f, 0xe3, 0xff, 0xc1, 0x9e, 0xcd, 0x9a, 0x56, 0x52, 0xb4, 0x32, 0x87, - 0xe4, 0x05, 0x68, 0x3e, 0x06, 0xe4, 0x32, 0x37, 0x97, 0xfa, 0x05, 0x8e, 0x0d, 0x4b, 0x7e, 0x4d, - 0xc0, 0xd0, 0x72, 0x4d, 0x55, 0xfd, 0x7b, 0x83, 0x17, 0x7d, 0x05, 0xc8, 0x99, 0xf0, 0x12, 0xad, - 0xd9, 0xda, 0x29, 0x43, 0xf0, 0x5d, 0xd8, 0x5b, 0x75, 0x58, 0x34, 0xf2, 0x3e, 0x17, 0x83, 0x37, - 0xf3, 0xe8, 0x4a, 0x97, 0x34, 0xe0, 0x22, 0x31, 0x87, 0xfc, 0xdf, 0x76, 0x88, 0x55, 0x33, 0xa8, - 0xc9, 0x81, 0xbb, 0x19, 0xf0, 0x44, 0x18, 0xf0, 0xd2, 0xa3, 0xaa, 0x62, 0xd4, 0x97, 0xb9, 0x95, - 0xe7, 0xe7, 0x95, 0x2e, 0xdb, 0x27, 0x6c, 0x90, 0x21, 0x5f, 0x07, 0xe6, 0x78, 0x7e, 0xba, 0x76, - 0x98, 0xaa, 0xec, 0x98, 0x64, 0xb1, 0xbb, 0x90, 0x82, 0x1e, 0x9b, 0x20, 0x51, 0x45, 0x61, 0xdc, - 0x26, 0x0d, 0x44, 0xe6, 0x5d, 0xf5, 0x17, 0xa2, 0xa1, 0x6e, 0x6a, 0xb7, 0x6d, 0x5e, 0x49, 0x7a, - 0x51, 0xd4, 0x3a, 0x2d, 0x33, 0xa2, 0x14, 0xa6, 0x4a, 0x40, 0xc6, 0xba, 0x4c, 0x57, 0x7c, 0xd1, - 0x11, 0x9f, 0xa8, 0x53, 0xa8, 0x5e, 0x11, 0x37, 0xa8, 0xd7, 0x2e, 0xb0, 0xe3, 0x89, 0x75, 0xcc, - 0x71, 0xba, 0x11, 0x32, 0x03, 0xff, 0x0c, 0x01, 0x12, 0xbc, 0x87, 0x20, 0xc9, 0x5b, 0x74, 0xc4, - 0x5a, 0x74, 0xfe, 0x41, 0x0e, 0x8b, 0x3a, 0xfc, 0xba, 0x5e, 0xaa, 0xa9, 0x94, 0xc5, 0x9b, 0xd3, - 0x91, 0xdd, 0x13, 0x7d, 0x43, 0xd3, 0x4f, 0x6e, 0x8d, 0x9e, 0xb4, 0x0f, 0x2a, 0x2a, 0x7c, 0x30, - 0x16, 0xe6, 0x83, 0x2b, 0xfc, 0xc1, 0x81, 0x03, 0x70, 0x33, 0x72, 0x08, 0x0e, 0x32, 0xec, 0x75, - 0xbb, 0xab, 0x51, 0x74, 0xcd, 0x6d, 0x03, 0x4b, 0xa2, 0x9d, 0x68, 0xf8, 0xc1, 0x8d, 0x10, 0x77, - 0x49, 0x3b, 0x3e, 0xb2, 0xd1, 0x92, 0xd2, 0xc1, 0x11, 0x7d, 0x20, 0x87, 0xc8, 0x7f, 0x7c, 0x08, - 0x92, 0x6c, 0x19, 0xfc, 0x19, 0x82, 0x03, 0x6d, 0xde, 0x1e, 0xf0, 0xe4, 0xae, 0x5d, 0x76, 0xdb, - 0xa7, 0x8c, 0xf4, 0x54, 0x6c, 0x3b, 0x2e, 0x8f, 0xe4, 0xdf, 0xff, 0xee, 0x97, 0xa7, 0x89, 0x33, - 0xf8, 0x74, 0x2e, 0xc2, 0x33, 0x8f, 0x20, 0xf9, 0x0d, 0x02, 0xdc, 0xda, 0xec, 0xe3, 0xd9, 0x8e, - 0x5e, 0x08, 0x38, 0xff, 0x8b, 0x7f, 0xe1, 0x75, 0x81, 0x5c, 0x66, 0x1a, 0x66, 0xf0, 0x54, 0x14, - 0x0d, 0x39, 0xb3, 0x95, 0xf9, 0x57, 0x08, 0xf6, 0xb7, 0xe0, 0xe3, 0x99, 0xf8, 0x9c, 0x1c, 0x39, - 0xb3, 0x9d, 0x98, 0x0a, 0x35, 0xf3, 0x4c, 0xcd, 0x34, 0x9e, 0xec, 0x4c, 0x0d, 0xfe, 0x12, 0xc1, - 0xa0, 0xff, 0x35, 0x03, 0x4f, 0x47, 0x8e, 0x0f, 0xdf, 0x03, 0x49, 0x7a, 0xa6, 0x03, 0x4b, 0xa1, - 0xe4, 0x12, 0x53, 0x32, 0x85, 0x2f, 0x44, 0x52, 0x42, 0xfd, 0x9c, 0x9f, 0x21, 0xe8, 0x6f, 0x78, - 0x3c, 0xc0, 0x13, 0xbb, 0x3b, 0xb5, 0xe5, 0x75, 0x22, 0x7d, 0x3e, 0x9e, 0x91, 0x60, 0x7e, 0x8e, - 0x31, 0x3f, 0x8d, 0xc7, 0xc2, 0x98, 0x9b, 0x55, 0xdd, 0xca, 0x89, 0xc3, 0x1f, 0x7f, 0x8a, 0x00, - 0x3c, 0x24, 0x9c, 0x8f, 0xb1, 0xac, 0x43, 0x75, 0x22, 0x96, 0x8d, 0x60, 0x3a, 0xc7, 0x98, 0x4e, - 0xe2, 0xf3, 0x51, 0x99, 0xe6, 0x1e, 0xbb, 0x97, 0xd0, 0x13, 0xfc, 0x39, 0x82, 0x81, 0xa6, 0xe7, - 0x05, 0x7c, 0x21, 0x12, 0x09, 0x7f, 0x27, 0x97, 0x9e, 0x8c, 0x6b, 0x16, 0x27, 0xd8, 0x19, 0x7d, - 0xdd, 0xb1, 0x6d, 0x12, 0xf0, 0x3d, 0x82, 0x41, 0x7f, 0x33, 0x1b, 0x21, 0xd8, 0x03, 0x9e, 0x23, - 0x22, 0x04, 0x7b, 0x50, 0xe7, 0x4c, 0xae, 0x31, 0x25, 0x4b, 0xf8, 0xbf, 0xd1, 0x94, 0x34, 0xed, - 0x43, 0xee, 0x71, 0xd3, 0x65, 0xfb, 0x04, 0xff, 0x80, 0xe0, 0x40, 0x9b, 0x06, 0x17, 0xef, 0x7e, - 0x4c, 0x06, 0x77, 0xdb, 0xe9, 0xb9, 0xce, 0x8c, 0x85, 0xbe, 0x45, 0xa6, 0x6f, 0x1e, 0xcf, 0x85, - 0xe9, 0x2b, 0xb9, 0x00, 0x01, 0xfb, 0xf5, 0x3b, 0x82, 0xe1, 0xf6, 0xcd, 0x10, 0x9e, 0x8f, 0xe8, - 0xfb, 0x80, 0x46, 0x39, 0x7d, 0xb9, 0x63, 0x7b, 0xa1, 0xf0, 0x16, 0x53, 0x78, 0x0d, 0xaf, 0xc6, - 0x51, 0x18, 0xbe, 0x8f, 0xcf, 0x11, 0xec, 0x6f, 0x29, 0x3e, 0x23, 0x5c, 0x2c, 0x41, 0x7d, 0x5b, - 0x84, 0x8b, 0x25, 0xb0, 0xd6, 0x25, 0x93, 0x4c, 0xdf, 0x39, 0x9c, 0x8d, 0xa8, 0xcf, 0x39, 0xda, - 0xbe, 0x46, 0x30, 0xd8, 0xd2, 0xac, 0x4c, 0xc7, 0x26, 0x12, 0x3d, 0xc7, 0x82, 0x6a, 0x60, 0xb2, - 0xc0, 0x14, 0xcc, 0xe1, 0xd9, 0x78, 0x0a, 0x9a, 0x22, 0xf0, 0x5b, 0x04, 0x43, 0xed, 0x0a, 0x56, - 0x3c, 0x17, 0xe3, 0xce, 0x6e, 0x29, 0x98, 0xd3, 0x97, 0x3a, 0xb4, 0x8e, 0x73, 0x8c, 0xbb, 0x03, - 0xfe, 0x30, 0xfb, 0x04, 0xc1, 0x01, 0xe7, 0x16, 0x6e, 0x28, 0x9b, 0x23, 0xdc, 0x98, 0xad, 0xf5, - 0x77, 0x84, 0x1b, 0xb3, 0x4d, 0x65, 0x1e, 0xed, 0xc6, 0xac, 0x30, 0xc3, 0x0d, 0x56, 0x0c, 0xe3, - 0x8f, 0x10, 0xf4, 0xb9, 0xe5, 0x36, 0x1e, 0xdf, 0x75, 0x55, 0x7f, 0xcd, 0x9e, 0xce, 0xc7, 0x31, - 0x11, 0x34, 0xcf, 0x32, 0x9a, 0xff, 0xc6, 0xff, 0x0a, 0xa3, 0x59, 0x75, 0xcc, 0x16, 0xb6, 0x5e, - 0xbc, 0xce, 0xa0, 0x97, 0xaf, 0x33, 0xe8, 0xe7, 0xd7, 0x19, 0xf4, 0xc1, 0x9b, 0x4c, 0xd7, 0xcb, - 0x37, 0x99, 0xae, 0x1f, 0xdf, 0x64, 0xba, 0xee, 0xdd, 0x68, 0xe8, 0x4a, 0x57, 0x1d, 0xa8, 0x35, - 0xb9, 0x60, 0x7a, 0xc0, 0x67, 0x8b, 0xba, 0x41, 0x1b, 0x3f, 0xb7, 0x64, 0x45, 0x13, 0x3e, 0x30, - 0xbd, 0x55, 0x59, 0x07, 0x5b, 0x48, 0xb1, 0xff, 0x01, 0x9d, 0xf8, 0x33, 0x00, 0x00, 0xff, 0xff, - 0x51, 0xb6, 0xaa, 0x16, 0xd0, 0x1d, 0x00, 0x00, + // 1839 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xdf, 0x6f, 0x13, 0xcb, + 0x15, 0xce, 0x38, 0xb1, 0x9b, 0x9c, 0xdc, 0xdc, 0x1b, 0x86, 0x90, 0x1b, 0x0c, 0x98, 0x74, 0xa2, + 0xd2, 0xdc, 0xab, 0x8b, 0x4d, 0x1c, 0xf2, 0x93, 0x10, 0xaa, 0x34, 0x09, 0x09, 0x24, 0x10, 0x16, + 0x2a, 0x15, 0x54, 0xc9, 0xac, 0xed, 0x89, 0xb3, 0x64, 0xbd, 0xeb, 0xec, 0x8f, 0x08, 0x0b, 0xf1, + 0x52, 0xf5, 0x0f, 0xa8, 0xc4, 0x43, 0xdf, 0x2a, 0xf5, 0x95, 0xc7, 0xf6, 0xad, 0x0f, 0xad, 0xc4, + 0x43, 0x85, 0x5a, 0xa9, 0xa2, 0xa2, 0xaa, 0xaa, 0x3e, 0xa0, 0x0a, 0xfa, 0x50, 0x55, 0xfd, 0x03, + 0xfa, 0x58, 0xed, 0xcc, 0xec, 0xae, 0xbd, 0xf6, 0x6e, 0x76, 0x5d, 0x1e, 0xe8, 0x13, 0xd9, 0xf1, + 0x9c, 0x6f, 0xbe, 0xef, 0xcc, 0x39, 0x33, 0xe7, 0x0c, 0x70, 0x49, 0xd1, 0x9e, 0xd0, 0x8a, 0xa5, + 0x1c, 0xd3, 0x02, 0x7d, 0x5a, 0x39, 0x90, 0xb5, 0x1a, 0x2d, 0x1c, 0xcf, 0x94, 0xa9, 0x25, 0xcf, + 0x14, 0x8e, 0x6c, 0x6a, 0x34, 0xf3, 0x0d, 0x43, 0xb7, 0x74, 0x9c, 0xf5, 0xe6, 0xe5, 0xdd, 0x79, + 0x79, 0x31, 0x2f, 0x7b, 0xbe, 0xa6, 0xeb, 0x35, 0x95, 0x16, 0xe4, 0x86, 0x52, 0x90, 0x35, 0x4d, + 0xb7, 0x64, 0x4b, 0xd1, 0x35, 0x93, 0x5b, 0x66, 0xbf, 0x8a, 0x58, 0xc1, 0x83, 0xe2, 0x53, 0xa7, + 0x23, 0xa6, 0xd6, 0xa8, 0x46, 0x4d, 0xc5, 0x05, 0x1d, 0xab, 0xe9, 0x35, 0x9d, 0xfd, 0x59, 0x70, + 0xfe, 0xe2, 0xa3, 0xe4, 0x2e, 0xc0, 0x7d, 0xbb, 0x2c, 0x57, 0x2a, 0xba, 0xad, 0x59, 0x78, 0x1c, + 0x32, 0x96, 0x21, 0x57, 0xa9, 0x31, 0x81, 0x26, 0xd1, 0xf4, 0x90, 0x24, 0xbe, 0xf0, 0x57, 0x30, + 0x6a, 0x7a, 0xb3, 0x4a, 0x9a, 0xae, 0x55, 0xe8, 0x44, 0x6a, 0x12, 0x4d, 0x8f, 0x48, 0x5f, 0xf8, + 0xe3, 0x77, 0x9c, 0x61, 0x72, 0x1e, 0xb2, 0xf7, 0x1c, 0x27, 0x6c, 0x08, 0x36, 0x7b, 0xb2, 0x21, + 0xd7, 0x4d, 0x89, 0x1e, 0xd9, 0xd4, 0xb4, 0x48, 0x09, 0xce, 0x75, 0xfd, 0xd5, 0x6c, 0xe8, 0x9a, + 0x49, 0xf1, 0xf7, 0x20, 0xd3, 0x60, 0x23, 0x6c, 0xfd, 0xe1, 0x22, 0xc9, 0x87, 0xfb, 0x30, 0xcf, + 0x6d, 0xd7, 0x06, 0x5e, 0xbf, 0xbb, 0xd8, 0x27, 0x09, 0x3b, 0xf2, 0x02, 0x41, 0x8e, 0xad, 0xe0, + 0xab, 0x5a, 0xa7, 0x0d, 0xdd, 0x54, 0x2c, 0x97, 0x03, 0x9e, 0x82, 0x91, 0x16, 0x31, 0x4a, 0x55, + 0x68, 0xfd, 0xcc, 0x1f, 0xdc, 0xae, 0xe2, 0x1d, 0x00, 0xff, 0x9b, 0x69, 0x1d, 0x2e, 0x5e, 0x8a, + 0x62, 0xe3, 0xaf, 0xc7, 0x18, 0x21, 0xa9, 0xc5, 0x9e, 0xfc, 0x0b, 0xc1, 0xc5, 0x50, 0x56, 0x42, + 0x3b, 0x85, 0xc1, 0xaa, 0x18, 0x9b, 0x40, 0x93, 0xfd, 0xd3, 0xc3, 0xc5, 0xed, 0xa8, 0xf5, 0x4e, + 0x80, 0xcb, 0xbb, 0x03, 0x1b, 0x9a, 0x65, 0x34, 0x25, 0x0f, 0x3a, 0xfb, 0x18, 0x46, 0xda, 0x7e, + 0xc2, 0xa3, 0xd0, 0x7f, 0x48, 0x9b, 0xc2, 0x09, 0xce, 0x9f, 0x78, 0x09, 0xd2, 0xc7, 0xb2, 0x6a, + 0x53, 0x21, 0x7b, 0x2a, 0x8a, 0x86, 0xc0, 0x92, 0xb8, 0xc5, 0x72, 0x6a, 0x11, 0x91, 0x1c, 0x9c, + 0x6f, 0xdb, 0xe3, 0x35, 0x59, 0x95, 0xb5, 0x0a, 0xf5, 0x62, 0x60, 0x1f, 0x2e, 0x84, 0xfc, 0x2e, + 0x3c, 0xb1, 0x01, 0x83, 0x65, 0x31, 0x26, 0x3c, 0x11, 0x49, 0x41, 0xd8, 0x8b, 0x40, 0xf0, 0x4c, + 0xc9, 0x23, 0xb1, 0x4e, 0x87, 0x93, 0x12, 0x05, 0xc2, 0x18, 0xa4, 0xab, 0x54, 0xd3, 0xeb, 0xcc, + 0x19, 0x43, 0x12, 0xff, 0x20, 0x72, 0x58, 0x94, 0x79, 0x22, 0x6e, 0xb4, 0x6d, 0x67, 0x6c, 0x3f, + 0x7a, 0x46, 0x64, 0x06, 0xbe, 0xe4, 0x4b, 0x34, 0x74, 0x6b, 0x57, 0x36, 0x0e, 0xa9, 0x1f, 0xc1, + 0xe3, 0x90, 0x31, 0x2d, 0xd9, 0xb2, 0x4d, 0x37, 0x4d, 0xf9, 0x17, 0xf9, 0x11, 0x4c, 0x74, 0x9a, + 0x78, 0xa9, 0xf5, 0xad, 0x3a, 0x1f, 0x12, 0x3e, 0x8d, 0x8e, 0x66, 0x0f, 0x41, 0x72, 0xcd, 0xc8, + 0x1c, 0x8c, 0x07, 0xd0, 0x5d, 0x3e, 0xe7, 0x60, 0x88, 0x4f, 0xf2, 0x9d, 0x38, 0xc8, 0x07, 0xb6, + 0xab, 0xe4, 0x61, 0x87, 0x0e, 0x8f, 0xd3, 0x2a, 0x64, 0xf8, 0x34, 0xe1, 0xa1, 0xb8, 0x94, 0x84, + 0x15, 0xb9, 0x03, 0x67, 0x3d, 0xe8, 0xbb, 0x46, 0x95, 0x1a, 0x65, 0x5d, 0x3f, 0x8c, 0x43, 0xca, + 0xd9, 0x55, 0x55, 0xa9, 0x2b, 0x3c, 0xb3, 0x07, 0x24, 0xfe, 0x41, 0x5e, 0x21, 0x71, 0x78, 0x05, + 0x00, 0x05, 0xdd, 0x3d, 0x18, 0x2d, 0xdb, 0x4d, 0xb3, 0xd4, 0x30, 0x94, 0x0a, 0x2d, 0xa9, 0xf4, + 0x98, 0xaa, 0x71, 0x7c, 0xb9, 0xe7, 0x4c, 0xdf, 0x71, 0x66, 0x4b, 0x9f, 0x3b, 0xf6, 0xfe, 0x37, + 0x96, 0xe0, 0x94, 0x49, 0x55, 0xb5, 0x1d, 0x32, 0x95, 0x08, 0xf2, 0x0b, 0x06, 0xe0, 0x0f, 0x90, + 0xc7, 0x22, 0xfd, 0x1e, 0xb0, 0xa3, 0xdb, 0x53, 0x62, 0xc6, 0xf2, 0x4b, 0x47, 0x4a, 0xa4, 0x3a, + 0x53, 0x82, 0xbc, 0x4c, 0xc1, 0x99, 0x07, 0x86, 0x52, 0xaf, 0xd3, 0xaa, 0x03, 0xbf, 0xe3, 0xf8, + 0x8e, 0xad, 0x81, 0xd7, 0x21, 0xcd, 0x94, 0x70, 0xdc, 0xb5, 0xbc, 0x93, 0x91, 0x7f, 0x7b, 0x77, + 0xf1, 0x52, 0x4d, 0xb1, 0x0e, 0xec, 0x72, 0xbe, 0xa2, 0xd7, 0x0b, 0x15, 0xdd, 0xac, 0xeb, 0xa6, + 0xf8, 0xe7, 0xb2, 0x59, 0x3d, 0x2c, 0x58, 0xcd, 0x06, 0x35, 0xf3, 0xeb, 0xb4, 0x22, 0x71, 0x63, + 0x7c, 0x0b, 0x06, 0x8f, 0x6c, 0x59, 0xb3, 0x14, 0xab, 0xc9, 0xd7, 0x4f, 0x0c, 0xe4, 0xd9, 0x3b, + 0x58, 0xfb, 0x8a, 0xaa, 0xca, 0x65, 0x95, 0x4e, 0xf4, 0xf7, 0x86, 0xe5, 0xda, 0x3b, 0x41, 0xa3, + 0x98, 0x6b, 0x76, 0x73, 0x62, 0x60, 0x12, 0x4d, 0x0f, 0x4a, 0xfc, 0x03, 0x5f, 0x00, 0xd0, 0x1d, + 0xf1, 0xa5, 0x03, 0xd9, 0x3c, 0x98, 0x48, 0x33, 0x7f, 0x0d, 0xb1, 0x91, 0x2d, 0xd9, 0x3c, 0x20, + 0x4f, 0xc4, 0x29, 0xd4, 0xb9, 0x1d, 0x22, 0xaa, 0xb6, 0x21, 0xc3, 0x66, 0xbb, 0x79, 0x39, 0x13, + 0xb5, 0xf1, 0x5d, 0xdd, 0x2e, 0x09, 0x00, 0xf2, 0x40, 0xdc, 0x32, 0xeb, 0xd4, 0x50, 0x8e, 0x65, + 0x07, 0xe1, 0x63, 0x64, 0xc5, 0x6b, 0x04, 0x93, 0xe1, 0xb0, 0xff, 0x57, 0xb9, 0xb1, 0x0f, 0xa4, + 0x65, 0x33, 0x02, 0x7a, 0x3e, 0x62, 0x86, 0xfc, 0x27, 0x05, 0xe7, 0xc4, 0x56, 0xf9, 0x8b, 0x7c, + 0xd2, 0x79, 0xb2, 0xc9, 0x8e, 0xe2, 0x9a, 0xa2, 0xf5, 0x98, 0x25, 0xc2, 0xba, 0x2d, 0xdf, 0x06, + 0x3e, 0x56, 0xbe, 0xa5, 0xc3, 0xf3, 0x2d, 0x13, 0xcc, 0xb7, 0x63, 0x98, 0x8a, 0xdc, 0x62, 0x11, + 0xaf, 0x77, 0x03, 0x59, 0xb7, 0x10, 0x23, 0xeb, 0xba, 0x6d, 0xa5, 0x97, 0x7b, 0x0b, 0x22, 0xcf, + 0xfd, 0x49, 0x31, 0x2f, 0xed, 0x9f, 0x23, 0x80, 0x96, 0xb0, 0xff, 0xe4, 0x42, 0x83, 0xfc, 0x16, + 0xc1, 0xd8, 0x1e, 0x35, 0x1a, 0xd4, 0xb2, 0x65, 0x95, 0x8b, 0xba, 0x6f, 0xc9, 0x96, 0x93, 0xf3, + 0xc3, 0x6e, 0x9e, 0x68, 0xfb, 0xba, 0xb8, 0xc3, 0x0b, 0x91, 0xb9, 0xd9, 0x0e, 0xb3, 0xad, 0xed, + 0xeb, 0x12, 0xd4, 0xbd, 0xbf, 0xf1, 0x0f, 0xe0, 0xb3, 0x7d, 0x5b, 0xab, 0x2a, 0x5a, 0x8d, 0x43, + 0xf2, 0x02, 0xb4, 0x98, 0x00, 0x72, 0x93, 0x9b, 0x4b, 0xc3, 0x02, 0xc7, 0x81, 0x25, 0xff, 0x4c, + 0xc1, 0xd8, 0xa6, 0xad, 0xaa, 0xc1, 0xbd, 0xc1, 0xeb, 0x81, 0x02, 0xe4, 0x9b, 0xe8, 0x12, 0xad, + 0xdd, 0xda, 0x2d, 0x43, 0xf0, 0x43, 0xf8, 0xbc, 0xe1, 0xb2, 0x68, 0xe5, 0x7d, 0x25, 0x01, 0x6f, + 0xe6, 0xd1, 0xad, 0x3e, 0x69, 0xc4, 0x43, 0x62, 0x0e, 0xf9, 0xa1, 0xe3, 0x10, 0xcb, 0x36, 0xa8, + 0xc9, 0x81, 0xfb, 0x19, 0xf0, 0x6c, 0x14, 0xf0, 0xc6, 0xd3, 0x86, 0x62, 0x34, 0x37, 0xb9, 0x95, + 0xef, 0xe7, 0xad, 0x3e, 0xc7, 0x27, 0x6c, 0x90, 0x21, 0xef, 0x02, 0x73, 0x3c, 0x3f, 0x5d, 0x7b, + 0x4c, 0x55, 0x76, 0x4c, 0xb2, 0xd8, 0x5d, 0xcb, 0xc0, 0x80, 0x43, 0x90, 0xa8, 0xa2, 0x30, 0xee, + 0x92, 0x06, 0x22, 0xf3, 0x6e, 0x05, 0x0b, 0xd1, 0x48, 0x37, 0x75, 0xdb, 0x36, 0xbf, 0x24, 0xbd, + 0x26, 0x6a, 0x9d, 0x8e, 0x19, 0x71, 0x0a, 0x53, 0x25, 0x24, 0x63, 0x3d, 0xa6, 0x5b, 0x81, 0xe8, + 0x48, 0x4e, 0xd4, 0x2d, 0x54, 0x6f, 0x8a, 0x1b, 0xd4, 0x6f, 0x17, 0xd8, 0xf1, 0xc4, 0x3a, 0xe6, + 0x24, 0xdd, 0x08, 0x59, 0x82, 0x6f, 0x47, 0x00, 0x09, 0xde, 0x63, 0x90, 0xe6, 0x2d, 0x3a, 0x62, + 0x2d, 0x3a, 0xff, 0x20, 0x67, 0x45, 0x1d, 0xbe, 0xab, 0x57, 0x6d, 0x95, 0xb2, 0x78, 0x73, 0x3b, + 0xb2, 0x47, 0xa2, 0x6f, 0x68, 0xfb, 0xc9, 0xab, 0xd1, 0xd3, 0xce, 0x41, 0x45, 0x85, 0x0f, 0xa6, + 0xa3, 0x7c, 0x70, 0x93, 0x3f, 0x38, 0x70, 0x00, 0x6e, 0x46, 0xbe, 0x84, 0x33, 0x0c, 0x7b, 0xcf, + 0xe9, 0x6a, 0x14, 0x5d, 0xf3, 0xda, 0xc0, 0x29, 0x21, 0x65, 0x47, 0x39, 0xb2, 0x95, 0xaa, 0x62, + 0x35, 0x77, 0x15, 0x4d, 0xd1, 0x6a, 0x7b, 0xba, 0xa2, 0x79, 0x87, 0x26, 0xa9, 0x8a, 0x9e, 0xa3, + 0xc5, 0xda, 0x0b, 0x23, 0x8f, 0x97, 0x13, 0x44, 0xf9, 0x78, 0x99, 0xeb, 0xe2, 0x88, 0x66, 0x51, + 0x70, 0xfc, 0x19, 0x12, 0x75, 0x41, 0x08, 0x17, 0xb1, 0xe4, 0x11, 0x5c, 0xb0, 0x74, 0x4b, 0x56, + 0x4b, 0xaa, 0x3b, 0xad, 0x54, 0x67, 0xf3, 0x4a, 0x0d, 0x36, 0xb1, 0xc7, 0x23, 0x3b, 0xcb, 0x40, + 0xbb, 0x2e, 0x5d, 0xfc, 0xc9, 0x59, 0x48, 0x33, 0x66, 0xf8, 0xd7, 0x08, 0x4e, 0x77, 0x79, 0x3a, + 0xc1, 0xf3, 0x27, 0x3e, 0x12, 0x74, 0x7d, 0x89, 0xc9, 0x2e, 0x24, 0xb6, 0xe3, 0x5e, 0x20, 0xc5, + 0x1f, 0xbf, 0xfd, 0xc7, 0x8b, 0xd4, 0x37, 0xf8, 0xeb, 0x42, 0x8c, 0x57, 0x2a, 0x41, 0xf2, 0x8f, + 0x08, 0x70, 0xe7, 0x5b, 0x05, 0x5e, 0xee, 0xe9, 0x81, 0x83, 0xf3, 0xbf, 0xf6, 0x3f, 0x3c, 0x8e, + 0x90, 0x1b, 0x4c, 0xc3, 0x12, 0x5e, 0x88, 0xa3, 0xa1, 0x60, 0x76, 0x32, 0xff, 0x3d, 0x82, 0x53, + 0x1d, 0xf8, 0x78, 0x29, 0x39, 0x27, 0x57, 0xce, 0x72, 0x2f, 0xa6, 0x42, 0xcd, 0x2a, 0x53, 0xb3, + 0x88, 0xe7, 0x7b, 0x53, 0x83, 0x7f, 0x87, 0x60, 0x34, 0xf8, 0x18, 0x83, 0x17, 0x63, 0xc7, 0x47, + 0xe0, 0x7d, 0x27, 0xbb, 0xd4, 0x83, 0xa5, 0x50, 0x72, 0x9d, 0x29, 0x59, 0xc0, 0x73, 0xb1, 0x94, + 0xd0, 0x20, 0xe7, 0x97, 0x08, 0x86, 0x5b, 0xde, 0x3e, 0xf0, 0xec, 0xc9, 0x4e, 0xed, 0x78, 0x5c, + 0xc9, 0x5e, 0x4d, 0x66, 0x24, 0x98, 0x5f, 0x61, 0xcc, 0xbf, 0xc6, 0xd3, 0x51, 0xcc, 0xcd, 0x86, + 0x6e, 0x15, 0xc4, 0xdd, 0x85, 0x7f, 0x85, 0x00, 0x7c, 0x24, 0x5c, 0x4c, 0xb0, 0xac, 0x4b, 0x75, + 0x36, 0x91, 0x8d, 0x60, 0xba, 0xc2, 0x98, 0xce, 0xe3, 0xab, 0x71, 0x99, 0x16, 0x9e, 0x79, 0x77, + 0xe8, 0x73, 0xfc, 0x1b, 0x04, 0x23, 0x6d, 0xaf, 0x23, 0x78, 0x2e, 0x16, 0x89, 0x60, 0x23, 0x9a, + 0x9d, 0x4f, 0x6a, 0x96, 0x24, 0xd8, 0x19, 0x7d, 0xdd, 0xb5, 0x6d, 0x13, 0xf0, 0x67, 0x04, 0xa3, + 0xc1, 0x5e, 0x3c, 0x46, 0xb0, 0x87, 0xbc, 0xa6, 0xc4, 0x08, 0xf6, 0xb0, 0xc6, 0x9f, 0xdc, 0x66, + 0x4a, 0x36, 0xf0, 0xf7, 0xe3, 0x29, 0x69, 0xdb, 0x87, 0xc2, 0xb3, 0xb6, 0x5a, 0xe1, 0x39, 0xfe, + 0x0b, 0x82, 0xd3, 0x5d, 0xfa, 0x73, 0x7c, 0xf2, 0x31, 0x19, 0xfe, 0x58, 0x90, 0x5d, 0xe9, 0xcd, + 0x58, 0xe8, 0x5b, 0x67, 0xfa, 0x56, 0xf1, 0x4a, 0x94, 0xbe, 0xaa, 0x07, 0x10, 0xb2, 0x5f, 0xff, + 0x46, 0x30, 0xde, 0xbd, 0x97, 0xc3, 0xab, 0x31, 0x7d, 0x1f, 0xd2, 0xe7, 0x67, 0x6f, 0xf4, 0x6c, + 0x2f, 0x14, 0xde, 0x63, 0x0a, 0x6f, 0xe3, 0xed, 0x24, 0x0a, 0xa3, 0xf7, 0xf1, 0x15, 0x82, 0x53, + 0x1d, 0xb5, 0x73, 0x8c, 0x8b, 0x25, 0xac, 0xed, 0x8c, 0x71, 0xb1, 0x84, 0x96, 0xea, 0x64, 0x9e, + 0xe9, 0xbb, 0x82, 0xf3, 0x31, 0xf5, 0xb9, 0x47, 0xdb, 0x1f, 0x10, 0x8c, 0x76, 0xf4, 0x5a, 0x8b, + 0x89, 0x89, 0xc4, 0xcf, 0xb1, 0xb0, 0x12, 0x9e, 0xac, 0x31, 0x05, 0x2b, 0x78, 0x39, 0x99, 0x82, + 0xb6, 0x08, 0xfc, 0x13, 0x82, 0xb1, 0x6e, 0xf5, 0x36, 0x5e, 0x49, 0x70, 0x67, 0x77, 0xd4, 0xfb, + 0xd9, 0xeb, 0x3d, 0x5a, 0x27, 0x39, 0xc6, 0xbd, 0x81, 0x60, 0x98, 0xfd, 0x12, 0xc1, 0x69, 0xf7, + 0x16, 0x6e, 0xa9, 0xfa, 0x63, 0xdc, 0x98, 0x9d, 0xed, 0x43, 0x8c, 0x1b, 0xb3, 0x4b, 0x63, 0x11, + 0xef, 0xc6, 0xac, 0x33, 0xc3, 0x12, 0x2b, 0xd3, 0xf1, 0x2f, 0x10, 0x0c, 0x79, 0x8d, 0x00, 0x9e, + 0x39, 0x71, 0xd5, 0x60, 0xcb, 0x91, 0x2d, 0x26, 0x31, 0x11, 0x34, 0x2f, 0x33, 0x9a, 0xdf, 0xc5, + 0xdf, 0x89, 0xa2, 0xd9, 0xf0, 0x58, 0xbd, 0x45, 0x70, 0xa6, 0x6b, 0x29, 0x8f, 0x4f, 0xde, 0xef, + 0xa8, 0x4e, 0x28, 0xbb, 0xda, 0xab, 0xb9, 0xd0, 0x71, 0x8d, 0xe9, 0x98, 0xc3, 0xb3, 0x51, 0x3a, + 0x42, 0x1a, 0x9b, 0xb5, 0x83, 0xd7, 0xef, 0x73, 0xe8, 0xcd, 0xfb, 0x1c, 0xfa, 0xfb, 0xfb, 0x1c, + 0xfa, 0xe9, 0x87, 0x5c, 0xdf, 0x9b, 0x0f, 0xb9, 0xbe, 0xbf, 0x7e, 0xc8, 0xf5, 0x3d, 0xba, 0xd3, + 0xd2, 0xe4, 0x6c, 0xbb, 0xc0, 0x3b, 0x72, 0xd9, 0xf4, 0x97, 0xb9, 0x5c, 0xd1, 0x0d, 0xda, 0xfa, + 0x79, 0x20, 0x2b, 0x9a, 0xd8, 0x59, 0xd3, 0xe7, 0xc0, 0x1a, 0xa2, 0x72, 0x86, 0xfd, 0xb7, 0xf4, + 0xec, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xe1, 0x35, 0x03, 0x2f, 0x65, 0x1f, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1979,6 +2061,8 @@ type QueryClient interface { ExchangeModuleState(ctx context.Context, in *QueryModuleStateRequest, opts ...grpc.CallOption) (*QueryModuleStateResponse, error) // Retrieves the entire exchange module's positions Positions(ctx context.Context, in *QueryPositionsRequest, opts ...grpc.CallOption) (*QueryPositionsResponse, error) + // Retrieves the account and total liquidity mining points + LiquidityMiningPoints(ctx context.Context, in *QueryLiquidityMiningPointsRequest, opts ...grpc.CallOption) (*QueryLiquidityMiningPointsResponse, error) } type queryClient struct { @@ -2124,6 +2208,15 @@ func (c *queryClient) Positions(ctx context.Context, in *QueryPositionsRequest, return out, nil } +func (c *queryClient) LiquidityMiningPoints(ctx context.Context, in *QueryLiquidityMiningPointsRequest, opts ...grpc.CallOption) (*QueryLiquidityMiningPointsResponse, error) { + out := new(QueryLiquidityMiningPointsResponse) + err := c.cc.Invoke(ctx, "/injective.exchange.v1beta1.Query/LiquidityMiningPoints", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // QueryServer is the server API for Query service. type QueryServer interface { // Retrieves exchange params @@ -2156,6 +2249,8 @@ type QueryServer interface { ExchangeModuleState(context.Context, *QueryModuleStateRequest) (*QueryModuleStateResponse, error) // Retrieves the entire exchange module's positions Positions(context.Context, *QueryPositionsRequest) (*QueryPositionsResponse, error) + // Retrieves the account and total liquidity mining points + LiquidityMiningPoints(context.Context, *QueryLiquidityMiningPointsRequest) (*QueryLiquidityMiningPointsResponse, error) } // UnimplementedQueryServer can be embedded to have forward compatible implementations. @@ -2207,6 +2302,9 @@ func (*UnimplementedQueryServer) ExchangeModuleState(ctx context.Context, req *Q func (*UnimplementedQueryServer) Positions(ctx context.Context, req *QueryPositionsRequest) (*QueryPositionsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Positions not implemented") } +func (*UnimplementedQueryServer) LiquidityMiningPoints(ctx context.Context, req *QueryLiquidityMiningPointsRequest) (*QueryLiquidityMiningPointsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LiquidityMiningPoints not implemented") +} func RegisterQueryServer(s grpc1.Server, srv QueryServer) { s.RegisterService(&_Query_serviceDesc, srv) @@ -2482,6 +2580,24 @@ func _Query_Positions_Handler(srv interface{}, ctx context.Context, dec func(int return interceptor(ctx, in, info, handler) } +func _Query_LiquidityMiningPoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryLiquidityMiningPointsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).LiquidityMiningPoints(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/injective.exchange.v1beta1.Query/LiquidityMiningPoints", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).LiquidityMiningPoints(ctx, req.(*QueryLiquidityMiningPointsRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _Query_serviceDesc = grpc.ServiceDesc{ ServiceName: "injective.exchange.v1beta1.Query", HandlerType: (*QueryServer)(nil), @@ -2546,6 +2662,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{ MethodName: "Positions", Handler: _Query_Positions_Handler, }, + { + MethodName: "LiquidityMiningPoints", + Handler: _Query_LiquidityMiningPoints_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "injective/exchange/v1beta1/query.proto", @@ -3924,6 +4044,29 @@ func (m *QueryPositionsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *QueryLiquidityMiningPointsRequest) 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 *QueryLiquidityMiningPointsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryLiquidityMiningPointsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + func (m *QueryPositionsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -3961,6 +4104,39 @@ func (m *QueryPositionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } +func (m *QueryLiquidityMiningPointsResponse) 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 *QueryLiquidityMiningPointsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryLiquidityMiningPointsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.TotalLiquidityMiningPoints.Size() + i -= size + if _, err := m.TotalLiquidityMiningPoints.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { offset -= sovQuery(v) base := offset @@ -4521,6 +4697,15 @@ func (m *QueryPositionsRequest) Size() (n int) { return n } +func (m *QueryLiquidityMiningPointsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + func (m *QueryPositionsResponse) Size() (n int) { if m == nil { return 0 @@ -4536,6 +4721,17 @@ func (m *QueryPositionsResponse) Size() (n int) { return n } +func (m *QueryLiquidityMiningPointsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.TotalLiquidityMiningPoints.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + func sovQuery(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -8118,6 +8314,56 @@ func (m *QueryPositionsRequest) Unmarshal(dAtA []byte) error { } return nil } +func (m *QueryLiquidityMiningPointsRequest) 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 ErrIntOverflowQuery + } + 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: QueryLiquidityMiningPointsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryLiquidityMiningPointsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *QueryPositionsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -8202,6 +8448,90 @@ func (m *QueryPositionsResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *QueryLiquidityMiningPointsResponse) 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 ErrIntOverflowQuery + } + 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: QueryLiquidityMiningPointsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryLiquidityMiningPointsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalLiquidityMiningPoints", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + 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 ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.TotalLiquidityMiningPoints.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipQuery(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/chain/exchange/types/spot_data.go b/chain/exchange/types/spot_data.go index b844dc64..55f97926 100644 --- a/chain/exchange/types/spot_data.go +++ b/chain/exchange/types/spot_data.go @@ -28,7 +28,6 @@ type SpotOrderStateExpansion struct { // ProcessSpotMarketOrderStateExpansions processes the spot market order state expansions. // NOTE: clearingPrice may be Nil func ProcessSpotMarketOrderStateExpansions( - isCanaryV2 bool, isMarketBuy bool, marketOrders []*SpotMarketOrder, marketFillQuantities []sdk.Dec, @@ -39,7 +38,6 @@ func ProcessSpotMarketOrderStateExpansions( for idx := range marketOrders { stateExpansions[idx] = getSpotMarketOrderStateExpansion( - isCanaryV2, marketOrders[idx], isMarketBuy, marketFillQuantities[idx], @@ -52,7 +50,6 @@ func ProcessSpotMarketOrderStateExpansions( } func ProcessRestingSpotLimitOrderExpansions( - isCanaryV2 bool, fills *OrderbookFills, isLimitBuy bool, clearingPrice sdk.Dec, @@ -67,7 +64,6 @@ func ProcessRestingSpotLimitOrderExpansions( if isLimitBuy { stateExpansions[idx] = getRestingSpotLimitBuyStateExpansion( - isCanaryV2, order, order.Hash(), fillQuantity, @@ -77,7 +73,6 @@ func ProcessRestingSpotLimitOrderExpansions( ) } else { stateExpansions[idx] = getSpotLimitSellStateExpansion( - isCanaryV2, order, fillQuantity, fillPrice, @@ -128,7 +123,6 @@ func (e *SpotOrderStateExpansion) UpdateDepositDeltas(baseDenomDepositDeltas Dep } func getSpotLimitSellStateExpansion( - isCanaryV2 bool, order *SpotLimitOrder, fillQuantity, fillPrice, tradeFeeRate, relayerFeeShare sdk.Dec, ) *SpotOrderStateExpansion { @@ -151,19 +145,13 @@ func getSpotLimitSellStateExpansion( quoteChangeAmount := orderNotional.Sub(traderFee) order.Fillable = order.Fillable.Sub(fillQuantity) - // get correct fee recipient while still supporting legacy (incorrect) fee recipient - feeRecipient := common.HexToAddress(order.OrderInfo.FeeRecipient) - if isCanaryV2 { - feeRecipient = order.FeeRecipient() - } - stateExpansion := SpotOrderStateExpansion{ // limit sells are debited by fillQuantity in base denom BaseChangeAmount: fillQuantity.Neg(), BaseRefundAmount: sdk.ZeroDec(), QuoteChangeAmount: quoteChangeAmount, QuoteRefundAmount: sdk.ZeroDec(), - FeeRecipient: feeRecipient, + FeeRecipient: order.FeeRecipient(), FeeRecipientReward: feeRecipientReward, AuctionFeeReward: auctionFeeReward, TraderFeeReward: traderFee.Abs(), @@ -177,7 +165,6 @@ func getSpotLimitSellStateExpansion( } func getRestingSpotLimitBuyStateExpansion( - isCanaryV2 bool, order *SpotLimitOrder, orderHash common.Hash, fillQuantity, fillPrice, makerFeeRate, relayerFeeShareRate sdk.Dec, @@ -222,18 +209,13 @@ func getRestingSpotLimitBuyStateExpansion( } order.Fillable = order.Fillable.Sub(fillQuantity) - // get correct fee recipient while still supporting legacy (incorrect) fee recipient - feeRecipient := common.HexToAddress(order.OrderInfo.FeeRecipient) - if isCanaryV2 { - feeRecipient = order.FeeRecipient() - } stateExpansion := SpotOrderStateExpansion{ BaseChangeAmount: baseChangeAmount, BaseRefundAmount: sdk.ZeroDec(), QuoteChangeAmount: quoteChangeAmount, QuoteRefundAmount: quoteRefund, - FeeRecipient: feeRecipient, + FeeRecipient: order.FeeRecipient(), FeeRecipientReward: feeRecipientReward, AuctionFeeReward: auctionFeeReward, TraderFeeReward: feeRebate, @@ -247,7 +229,6 @@ func getRestingSpotLimitBuyStateExpansion( } func getNewSpotLimitBuyStateExpansion( - isCanaryV2 bool, buyOrder *SpotLimitOrder, orderHash common.Hash, clearingPrice, fillQuantity, @@ -282,18 +263,12 @@ func getNewSpotLimitBuyStateExpansion( quoteRefundAmount := clearingRefund.Add(feeRefund) buyOrder.Fillable = buyOrder.Fillable.Sub(fillQuantity) - // get correct fee recipient while still supporting legacy (incorrect) fee recipient - feeRecipient := common.HexToAddress(buyOrder.OrderInfo.FeeRecipient) - if isCanaryV2 { - feeRecipient = buyOrder.FeeRecipient() - } - stateExpansion := SpotOrderStateExpansion{ BaseChangeAmount: baseChangeAmount, BaseRefundAmount: sdk.ZeroDec(), QuoteChangeAmount: quoteChangeAmount, QuoteRefundAmount: quoteRefundAmount, - FeeRecipient: feeRecipient, + FeeRecipient: buyOrder.FeeRecipient(), FeeRecipientReward: feeRecipientReward, AuctionFeeReward: auctionFeeReward, TraderFeeReward: sdk.ZeroDec(), @@ -307,7 +282,6 @@ func getNewSpotLimitBuyStateExpansion( } func getSpotMarketOrderStateExpansion( - isCanaryV2 bool, marketOrder *SpotMarketOrder, isMarketBuy bool, fillQuantity, clearingPrice sdk.Dec, @@ -347,18 +321,12 @@ func getSpotMarketOrderStateExpansion( } } - // get correct fee recipient while still supporting legacy (incorrect) fee recipient - feeRecipient := common.HexToAddress(marketOrder.OrderInfo.FeeRecipient) - if isCanaryV2 { - feeRecipient = marketOrder.FeeRecipient() - } - stateExpansion := SpotOrderStateExpansion{ BaseChangeAmount: baseChangeAmount, BaseRefundAmount: baseRefundAmount, QuoteChangeAmount: quoteChangeAmount, QuoteRefundAmount: quoteRefundAmount, - FeeRecipient: feeRecipient, + FeeRecipient: marketOrder.FeeRecipient(), FeeRecipientReward: feeRecipientReward, AuctionFeeReward: auctionFeeReward, TraderFeeReward: sdk.ZeroDec(), diff --git a/chain/exchange/types/spot_execution.go b/chain/exchange/types/spot_execution.go index c63000b2..017c3c22 100644 --- a/chain/exchange/types/spot_execution.go +++ b/chain/exchange/types/spot_execution.go @@ -15,6 +15,7 @@ type SpotBatchExecutionData struct { MarketOrderExecutionEvent *EventBatchSpotExecution LimitOrderExecutionEvent []*EventBatchSpotExecution NewOrdersEvent *EventNewSpotOrders + LiquidityMiningRewards LiquidityMiningRewards } func GetSpotMarketOrderBatchExecution( @@ -22,6 +23,7 @@ func GetSpotMarketOrderBatchExecution( market *SpotMarket, spotLimitOrderStateExpansions, spotMarketOrderStateExpansions []*SpotOrderStateExpansion, clearingPrice sdk.Dec, + liquidityMiningRewardsRate sdk.Dec, ) *SpotBatchExecutionData { baseDenomDepositDeltas := NewDepositDeltas() quoteDenomDepositDeltas := NewDepositDeltas() @@ -54,12 +56,13 @@ func GetSpotMarketOrderBatchExecution( } // Stage 3b: Process limit order events - limitOrderBatchEvent, filledDeltas := GetBatchExecutionEventsFromSpotLimitOrderStateExpansions( + limitOrderBatchEvent, filledDeltas, liquidityMiningRewards := GetBatchExecutionEventsFromSpotLimitOrderStateExpansions( !isMarketBuy, market.MarketID(), ExecutionType_LimitFill, spotLimitOrderStateExpansions, baseDenomDepositDeltas, quoteDenomDepositDeltas, + liquidityMiningRewardsRate, ) limitOrderExecutionEvent := make([]*EventBatchSpotExecution, 0) @@ -77,29 +80,29 @@ func GetSpotMarketOrderBatchExecution( LimitOrderFilledDeltas: filledDeltas, MarketOrderExecutionEvent: marketOrderBatchEvent, LimitOrderExecutionEvent: limitOrderExecutionEvent, + LiquidityMiningRewards: liquidityMiningRewards, } return batch } func GetSpotLimitMatchingBatchExecution( - isCanaryV2 bool, market *SpotMarket, orderbookStateChange *SpotOrderbookStateChange, clearingPrice sdk.Dec, + liquidityMiningRewardsRate sdk.Dec, ) *SpotBatchExecutionData { // Initialize map DepositKey subaccountID => Deposit Delta (availableBalanceDelta, totalDepositsDelta) baseDenomDepositDeltas := NewDepositDeltas() quoteDenomDepositDeltas := NewDepositDeltas() - limitBuyRestingOrderBatchEvent, limitSellRestingOrderBatchEvent, filledDeltas := orderbookStateChange.ProcessBothRestingSpotLimitOrderExpansions( - isCanaryV2, market.MarketID(), clearingPrice, market.MakerFeeRate, market.RelayerFeeShareRate, - baseDenomDepositDeltas, quoteDenomDepositDeltas, + limitBuyRestingOrderBatchEvent, limitSellRestingOrderBatchEvent, filledDeltas, liquidityMiningRewards := orderbookStateChange.ProcessBothRestingSpotLimitOrderExpansions( + market.MarketID(), clearingPrice, market.MakerFeeRate, market.RelayerFeeShareRate, + baseDenomDepositDeltas, quoteDenomDepositDeltas, liquidityMiningRewardsRate, ) // filled deltas are handled implicitly with the new resting spot limit orders limitBuyNewOrderBatchEvent, limitSellNewOrderBatchEvent, newRestingBuySpotLimitOrders, newRestingSellSpotLimitOrders := orderbookStateChange.ProcessBothTransientSpotLimitOrderExpansions( - isCanaryV2, market.MarketID(), clearingPrice, market.MakerFeeRate, market.TakerFeeRate, market.RelayerFeeShareRate, @@ -133,6 +136,7 @@ func GetSpotLimitMatchingBatchExecution( QuoteDenomDepositSubaccountIDs: quoteDenomDepositDeltas.GetSortedSubaccountKeys(), LimitOrderFilledDeltas: filledDeltas, LimitOrderExecutionEvent: eventBatchSpotExecution, + LiquidityMiningRewards: liquidityMiningRewards, } if len(newRestingBuySpotLimitOrders) > 0 || len(newRestingSellSpotLimitOrders) > 0 { @@ -151,7 +155,8 @@ func GetBatchExecutionEventsFromSpotLimitOrderStateExpansions( executionType ExecutionType, spotLimitOrderStateExpansions []*SpotOrderStateExpansion, baseDenomDepositDeltas DepositDeltas, quoteDenomDepositDeltas DepositDeltas, -) (*EventBatchSpotExecution, []*SpotLimitOrderDelta) { + liquidityMiningRewardsRate sdk.Dec, +) (*EventBatchSpotExecution, []*SpotLimitOrderDelta, LiquidityMiningRewards) { limitOrderBatchEvent := &EventBatchSpotExecution{ MarketId: marketID.Hex(), IsBuy: isBuy, @@ -162,6 +167,7 @@ func GetBatchExecutionEventsFromSpotLimitOrderStateExpansions( // array of (SubaccountIndexKey, fillableAmount) to update/delete filledDeltas := make([]*SpotLimitOrderDelta, 0, len(spotLimitOrderStateExpansions)) + liquidityMiningRewards := NewLiquidityMiningRewards() for idx := range spotLimitOrderStateExpansions { expansion := spotLimitOrderStateExpansions[idx] @@ -192,6 +198,14 @@ func GetBatchExecutionEventsFromSpotLimitOrderStateExpansions( } price := expansion.QuoteChangeAmount.Add(traderFee).Quo(expansion.BaseChangeAmount).Abs() + hasLiquidityMiningRewards := (executionType == ExecutionType_LimitFill || executionType == ExecutionType_LimitMatchRestingOrder) && liquidityMiningRewardsRate.IsPositive() + + if hasLiquidityMiningRewards { + addr := SubaccountIDToSdkAddress(expansion.SubaccountID) + newPoints := price.Mul(expansion.LimitOrderFillQuantity).Mul(liquidityMiningRewardsRate) + liquidityMiningRewards.AddPointsForAddress(addr.String(), newPoints) + } + var totalTradeFee sdk.Dec if hasNegativeMakerFee { @@ -213,5 +227,5 @@ func GetBatchExecutionEventsFromSpotLimitOrderStateExpansions( if len(trades) == 0 { limitOrderBatchEvent = nil } - return limitOrderBatchEvent, filledDeltas + return limitOrderBatchEvent, filledDeltas, liquidityMiningRewards } diff --git a/chain/exchange/types/spot_orderbook.go b/chain/exchange/types/spot_orderbook.go index 7c1e3f53..2400bb7d 100644 --- a/chain/exchange/types/spot_orderbook.go +++ b/chain/exchange/types/spot_orderbook.go @@ -56,51 +56,61 @@ func NewSpotOrderbookStateChange(transientBuyOrders []*SpotLimitOrder, transient // ProcessBothRestingSpotLimitOrderExpansions processes both the orderbook state change to produce the spot execution batch events and filledDelta. // Note: clearingPrice should be set to sdk.Dec{} for normal fills func (o *SpotOrderbookStateChange) ProcessBothRestingSpotLimitOrderExpansions( - isCanaryV2 bool, marketID common.Hash, clearingPrice sdk.Dec, tradeFeeRate, relayerFeeShareRate sdk.Dec, baseDenomDepositDeltas DepositDeltas, quoteDenomDepositDeltas DepositDeltas, -) (limitBuyRestingOrderBatchEvent *EventBatchSpotExecution, limitSellRestingOrderBatchEvent *EventBatchSpotExecution, filledDeltas []*SpotLimitOrderDelta) { + liquidityMiningRewardsRate sdk.Dec, +) ( + limitBuyRestingOrderBatchEvent *EventBatchSpotExecution, + limitSellRestingOrderBatchEvent *EventBatchSpotExecution, + filledDeltas []*SpotLimitOrderDelta, + liquidityMiningRewards LiquidityMiningRewards, +) { spotLimitBuyOrderStateExpansions := make([]*SpotOrderStateExpansion, 0) spotLimitSellOrderStateExpansions := make([]*SpotOrderStateExpansion, 0) filledDeltas = make([]*SpotLimitOrderDelta, 0) var currFilledDeltas []*SpotLimitOrderDelta + var buyLiquidityMiningRewards LiquidityMiningRewards + var sellLiquidityMiningRewards LiquidityMiningRewards if o.RestingBuyOrderbookFills != nil { - spotLimitBuyOrderStateExpansions = o.ProcessRestingSpotLimitOrderExpansions(isCanaryV2, true, clearingPrice, tradeFeeRate, relayerFeeShareRate) + spotLimitBuyOrderStateExpansions = o.ProcessRestingSpotLimitOrderExpansions(true, clearingPrice, tradeFeeRate, relayerFeeShareRate) // Process limit order events and filledDeltas - limitBuyRestingOrderBatchEvent, currFilledDeltas = GetBatchExecutionEventsFromSpotLimitOrderStateExpansions( + limitBuyRestingOrderBatchEvent, currFilledDeltas, buyLiquidityMiningRewards = GetBatchExecutionEventsFromSpotLimitOrderStateExpansions( true, marketID, ExecutionType_LimitMatchRestingOrder, spotLimitBuyOrderStateExpansions, baseDenomDepositDeltas, quoteDenomDepositDeltas, + liquidityMiningRewardsRate, ) filledDeltas = append(filledDeltas, currFilledDeltas...) } if o.RestingSellOrderbookFills != nil { - spotLimitSellOrderStateExpansions = o.ProcessRestingSpotLimitOrderExpansions(isCanaryV2, false, clearingPrice, tradeFeeRate, relayerFeeShareRate) + spotLimitSellOrderStateExpansions = o.ProcessRestingSpotLimitOrderExpansions(false, clearingPrice, tradeFeeRate, relayerFeeShareRate) // Process limit order events and filledDeltas - limitSellRestingOrderBatchEvent, currFilledDeltas = GetBatchExecutionEventsFromSpotLimitOrderStateExpansions( + limitSellRestingOrderBatchEvent, currFilledDeltas, sellLiquidityMiningRewards = GetBatchExecutionEventsFromSpotLimitOrderStateExpansions( false, marketID, ExecutionType_LimitMatchRestingOrder, spotLimitSellOrderStateExpansions, baseDenomDepositDeltas, quoteDenomDepositDeltas, + liquidityMiningRewardsRate, ) filledDeltas = append(filledDeltas, currFilledDeltas...) } + + liquidityMiningRewards = MergeLiquidityMiningRewards(buyLiquidityMiningRewards, sellLiquidityMiningRewards) return } // ProcessBothTransientSpotLimitOrderExpansions processes the transient spot limit orderbook state change. // Note: clearingPrice should be set to sdk.Dec{} for normal fills func (o *SpotOrderbookStateChange) ProcessBothTransientSpotLimitOrderExpansions( - isCanaryV2 bool, marketID common.Hash, clearingPrice sdk.Dec, makerFeeRate, takerFeeRate, relayerFeeShareRate sdk.Dec, @@ -114,24 +124,26 @@ func (o *SpotOrderbookStateChange) ProcessBothTransientSpotLimitOrderExpansions( ) { var expansions []*SpotOrderStateExpansion if o.TransientBuyOrderbookFills != nil { - expansions, newRestingBuySpotLimitOrders = o.processNewSpotLimitBuyExpansions(isCanaryV2,clearingPrice, makerFeeRate, takerFeeRate, relayerFeeShareRate) - limitBuyNewOrderBatchEvent, _ = GetBatchExecutionEventsFromSpotLimitOrderStateExpansions( + expansions, newRestingBuySpotLimitOrders = o.processNewSpotLimitBuyExpansions(clearingPrice, makerFeeRate, takerFeeRate, relayerFeeShareRate) + limitBuyNewOrderBatchEvent, _, _ = GetBatchExecutionEventsFromSpotLimitOrderStateExpansions( true, marketID, ExecutionType_LimitMatchNewOrder, expansions, baseDenomDepositDeltas, quoteDenomDepositDeltas, + sdk.ZeroDec(), ) } if o.TransientSellOrderbookFills != nil { - expansions, newRestingSellSpotLimitOrders = o.processNewSpotLimitSellExpansions(isCanaryV2, clearingPrice, takerFeeRate, relayerFeeShareRate) - limitSellNewOrderBatchEvent, _ = GetBatchExecutionEventsFromSpotLimitOrderStateExpansions( + expansions, newRestingSellSpotLimitOrders = o.processNewSpotLimitSellExpansions(clearingPrice, takerFeeRate, relayerFeeShareRate) + limitSellNewOrderBatchEvent, _, _ = GetBatchExecutionEventsFromSpotLimitOrderStateExpansions( false, marketID, ExecutionType_LimitMatchNewOrder, expansions, baseDenomDepositDeltas, quoteDenomDepositDeltas, + sdk.ZeroDec(), ) } return @@ -140,7 +152,6 @@ func (o *SpotOrderbookStateChange) ProcessBothTransientSpotLimitOrderExpansions( // ProcessRestingSpotLimitOrderExpansions processes the resting spot limit orderbook state change. // Note: clearingPrice should be set to sdk.Dec{} for normal fills func (o *SpotOrderbookStateChange) ProcessRestingSpotLimitOrderExpansions( - isCanaryV2 bool, isLimitBuy bool, clearingPrice sdk.Dec, makerFeeRate, relayerFeeShare sdk.Dec, @@ -151,12 +162,11 @@ func (o *SpotOrderbookStateChange) ProcessRestingSpotLimitOrderExpansions( } else { fills = o.RestingSellOrderbookFills } - return ProcessRestingSpotLimitOrderExpansions(isCanaryV2, fills, isLimitBuy, clearingPrice, makerFeeRate, relayerFeeShare) + return ProcessRestingSpotLimitOrderExpansions(fills, isLimitBuy, clearingPrice, makerFeeRate, relayerFeeShare) } // TODO: refactor to merge processNewSpotLimitBuyExpansions and processNewSpotLimitSellExpansions func (o *SpotOrderbookStateChange) processNewSpotLimitBuyExpansions( - isCanaryV2 bool, clearingPrice sdk.Dec, makerFeeRate, takerFeeRate, relayerFeeShare sdk.Dec, ) ([]*SpotOrderStateExpansion, []*SpotLimitOrder) { @@ -170,7 +180,6 @@ func (o *SpotOrderbookStateChange) processNewSpotLimitBuyExpansions( fillQuantity = orderbookFills.FillQuantities[idx] } stateExpansions[idx] = getNewSpotLimitBuyStateExpansion( - isCanaryV2, order, common.BytesToHash(order.OrderHash), clearingPrice, fillQuantity, @@ -187,7 +196,6 @@ func (o *SpotOrderbookStateChange) processNewSpotLimitBuyExpansions( // processNewSpotLimitSellExpansions processes. // Note: clearingPrice should be set to sdk.Dec{} for normal fills func (o *SpotOrderbookStateChange) processNewSpotLimitSellExpansions( - isCanaryV2 bool, clearingPrice sdk.Dec, takerFeeRate, relayerFeeShare sdk.Dec, ) ([]*SpotOrderStateExpansion, []*SpotLimitOrder) { @@ -202,7 +210,6 @@ func (o *SpotOrderbookStateChange) processNewSpotLimitSellExpansions( fillPrice = clearingPrice } stateExpansions[idx] = getSpotLimitSellStateExpansion( - isCanaryV2, order, fillQuantity, fillPrice, diff --git a/chain/exchange/types/tx.pb.go b/chain/exchange/types/tx.pb.go index 4ed735dc..d7abbd03 100644 --- a/chain/exchange/types/tx.pb.go +++ b/chain/exchange/types/tx.pb.go @@ -257,6 +257,7 @@ var xxx_messageInfo_MsgCreateSpotLimitOrder proto.InternalMessageInfo // MsgCreateSpotLimitOrderResponse defines the Msg/CreateSpotOrder response type. type MsgCreateSpotLimitOrderResponse struct { + OrderHash string `protobuf:"bytes,1,opt,name=order_hash,json=orderHash,proto3" json:"order_hash,omitempty"` } func (m *MsgCreateSpotLimitOrderResponse) Reset() { *m = MsgCreateSpotLimitOrderResponse{} } @@ -333,6 +334,7 @@ var xxx_messageInfo_MsgBatchCreateSpotLimitOrders proto.InternalMessageInfo // MsgBatchCreateSpotLimitOrdersResponse defines the Msg/BatchCreateSpotLimitOrders response type. type MsgBatchCreateSpotLimitOrdersResponse struct { + OrderHashes []string `protobuf:"bytes,1,rep,name=order_hashes,json=orderHashes,proto3" json:"order_hashes,omitempty"` } func (m *MsgBatchCreateSpotLimitOrdersResponse) Reset() { *m = MsgBatchCreateSpotLimitOrdersResponse{} } @@ -776,6 +778,7 @@ var xxx_messageInfo_MsgCreateDerivativeLimitOrder proto.InternalMessageInfo // MsgCreateDerivativeLimitOrderResponse defines the Msg/CreateDerivativeMarketOrder response type. type MsgCreateDerivativeLimitOrderResponse struct { + OrderHash string `protobuf:"bytes,1,opt,name=order_hash,json=orderHash,proto3" json:"order_hash,omitempty"` } func (m *MsgCreateDerivativeLimitOrderResponse) Reset() { *m = MsgCreateDerivativeLimitOrderResponse{} } @@ -852,6 +855,7 @@ var xxx_messageInfo_MsgBatchCreateDerivativeLimitOrders proto.InternalMessageInf // MsgBatchCreateDerivativeLimitOrdersResponse defines the Msg/BatchCreateDerivativeLimitOrders response type. type MsgBatchCreateDerivativeLimitOrdersResponse struct { + OrderHashes []string `protobuf:"bytes,1,rep,name=order_hashes,json=orderHashes,proto3" json:"order_hashes,omitempty"` } func (m *MsgBatchCreateDerivativeLimitOrdersResponse) Reset() { @@ -1010,6 +1014,7 @@ var xxx_messageInfo_MsgBatchCancelSpotOrders proto.InternalMessageInfo // MsgBatchCancelSpotOrdersResponse defines the Msg/BatchCancelSpotOrders response type. type MsgBatchCancelSpotOrdersResponse struct { + Success []bool `protobuf:"varint,1,rep,packed,name=success,proto3" json:"success,omitempty"` } func (m *MsgBatchCancelSpotOrdersResponse) Reset() { *m = MsgBatchCancelSpotOrdersResponse{} } @@ -1302,6 +1307,7 @@ var xxx_messageInfo_MsgBatchCancelDerivativeOrders proto.InternalMessageInfo // MsgBatchCancelDerivativeOrdersResponse defines the Msg/CancelDerivativeOrderResponse response type. type MsgBatchCancelDerivativeOrdersResponse struct { + Success []bool `protobuf:"varint,1,rep,packed,name=success,proto3" json:"success,omitempty"` } func (m *MsgBatchCancelDerivativeOrdersResponse) Reset() { @@ -2133,6 +2139,45 @@ func (m *DerivativeMarketBandOraclePromotionProposal) XXX_DiscardUnknown() { var xxx_messageInfo_DerivativeMarketBandOraclePromotionProposal proto.InternalMessageInfo +type LiquidityMiningCampaignProposal struct { + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + Campaign *LiquidityMiningCampaign `protobuf:"bytes,3,opt,name=campaign,proto3" json:"campaign,omitempty"` +} + +func (m *LiquidityMiningCampaignProposal) Reset() { *m = LiquidityMiningCampaignProposal{} } +func (m *LiquidityMiningCampaignProposal) String() string { return proto.CompactTextString(m) } +func (*LiquidityMiningCampaignProposal) ProtoMessage() {} +func (*LiquidityMiningCampaignProposal) Descriptor() ([]byte, []int) { + return fileDescriptor_bd45b74cb6d81462, []int{46} +} +func (m *LiquidityMiningCampaignProposal) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LiquidityMiningCampaignProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LiquidityMiningCampaignProposal.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 *LiquidityMiningCampaignProposal) XXX_Merge(src proto.Message) { + xxx_messageInfo_LiquidityMiningCampaignProposal.Merge(m, src) +} +func (m *LiquidityMiningCampaignProposal) XXX_Size() int { + return m.Size() +} +func (m *LiquidityMiningCampaignProposal) XXX_DiscardUnknown() { + xxx_messageInfo_LiquidityMiningCampaignProposal.DiscardUnknown(m) +} + +var xxx_messageInfo_LiquidityMiningCampaignProposal proto.InternalMessageInfo + func init() { proto.RegisterEnum("injective.exchange.v1beta1.ExchangeType", ExchangeType_name, ExchangeType_value) proto.RegisterType((*MsgDeposit)(nil), "injective.exchange.v1beta1.MsgDeposit") @@ -2181,6 +2226,7 @@ func init() { proto.RegisterType((*ExpiryFuturesMarketLaunchProposal)(nil), "injective.exchange.v1beta1.ExpiryFuturesMarketLaunchProposal") proto.RegisterType((*DerivativeMarketParamUpdateProposal)(nil), "injective.exchange.v1beta1.DerivativeMarketParamUpdateProposal") proto.RegisterType((*DerivativeMarketBandOraclePromotionProposal)(nil), "injective.exchange.v1beta1.DerivativeMarketBandOraclePromotionProposal") + proto.RegisterType((*LiquidityMiningCampaignProposal)(nil), "injective.exchange.v1beta1.LiquidityMiningCampaignProposal") } func init() { @@ -2188,144 +2234,150 @@ func init() { } var fileDescriptor_bd45b74cb6d81462 = []byte{ - // 2189 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0x4f, 0x6f, 0xdb, 0xc8, - 0x15, 0x37, 0x6d, 0x59, 0xb2, 0x9e, 0xff, 0xc4, 0xcb, 0x38, 0x8e, 0xc2, 0xc4, 0xb2, 0x62, 0x6f, - 0x12, 0x6f, 0x83, 0x48, 0x1b, 0x6f, 0xba, 0xdb, 0x64, 0xdb, 0xa6, 0xb1, 0x2d, 0x27, 0x02, 0xac, - 0xc4, 0x2b, 0x79, 0xb7, 0x45, 0x81, 0x56, 0x1d, 0x53, 0x13, 0x89, 0xb5, 0x44, 0x2a, 0x9c, 0x51, - 0x6a, 0x2f, 0x8a, 0x06, 0xe8, 0xa1, 0x0d, 0xd2, 0xed, 0xb6, 0x8b, 0xa2, 0x87, 0x16, 0x08, 0x10, - 0xf4, 0x54, 0xa0, 0xed, 0x07, 0xe8, 0x37, 0xd8, 0xe3, 0x1e, 0x8a, 0xa2, 0xd8, 0xc3, 0xa2, 0x48, - 0x2e, 0xbd, 0xf7, 0xd2, 0x63, 0xc1, 0x21, 0x35, 0xa2, 0x28, 0x52, 0xa4, 0x68, 0xd3, 0x1b, 0x04, - 0x7b, 0xb2, 0x38, 0xf3, 0xfe, 0xfc, 0xe6, 0xcd, 0x7b, 0xc3, 0x79, 0xef, 0xd1, 0xb0, 0xac, 0xa8, - 0x3f, 0xc6, 0x32, 0x55, 0x1e, 0xe2, 0x1c, 0xde, 0x97, 0xeb, 0x48, 0xad, 0xe1, 0xdc, 0xc3, 0xab, - 0xbb, 0x98, 0xa2, 0xab, 0x39, 0xba, 0x9f, 0x6d, 0xe9, 0x1a, 0xd5, 0x44, 0x89, 0x13, 0x65, 0x3b, - 0x44, 0x59, 0x8b, 0x48, 0x9a, 0xab, 0x69, 0x35, 0x8d, 0x91, 0xe5, 0x8c, 0x5f, 0x26, 0x87, 0x74, - 0xa1, 0x2b, 0x56, 0xd3, 0x91, 0xdc, 0xe8, 0x0a, 0x35, 0x1f, 0x2d, 0xb2, 0x37, 0x06, 0x68, 0xe7, - 0x9a, 0x4c, 0xd2, 0xb4, 0xac, 0x91, 0xa6, 0x46, 0x72, 0xbb, 0x88, 0x74, 0x69, 0x64, 0x4d, 0x51, - 0xcd, 0xf9, 0xa5, 0x8f, 0x04, 0x80, 0x22, 0xa9, 0x6d, 0xe0, 0x96, 0x46, 0x14, 0x2a, 0xce, 0x43, - 0x9c, 0x60, 0xb5, 0x8a, 0xf5, 0x94, 0x90, 0x11, 0x56, 0x92, 0x25, 0xeb, 0x49, 0x5c, 0x86, 0x69, - 0xd2, 0xde, 0x45, 0xb2, 0xac, 0xb5, 0x55, 0x5a, 0x51, 0xaa, 0xa9, 0x51, 0x36, 0x3d, 0xd5, 0x1d, - 0x2c, 0x54, 0xc5, 0x77, 0x20, 0x8e, 0x9a, 0xc6, 0xef, 0xd4, 0x58, 0x46, 0x58, 0x99, 0x5c, 0x3d, - 0x93, 0x35, 0x95, 0x67, 0x0d, 0xe5, 0x9d, 0x95, 0x67, 0xd7, 0x35, 0x45, 0x5d, 0x8b, 0x7d, 0xfa, - 0xc5, 0xe2, 0x48, 0xc9, 0x22, 0xbf, 0x31, 0xf1, 0xf8, 0xd9, 0xe2, 0xc8, 0x7f, 0x9e, 0x2d, 0x8e, - 0x2c, 0xcd, 0x81, 0xd8, 0x45, 0x53, 0xc2, 0xa4, 0xa5, 0xa9, 0x04, 0x2f, 0xfd, 0x5a, 0x80, 0xc9, - 0x22, 0xa9, 0x7d, 0x57, 0xa1, 0xf5, 0xaa, 0x8e, 0x7e, 0xf2, 0xa5, 0xa3, 0x3c, 0x05, 0x27, 0x6d, - 0x70, 0x38, 0xcc, 0x9f, 0xc1, 0xe9, 0x22, 0xa9, 0xad, 0xeb, 0x18, 0x51, 0x5c, 0x6e, 0x69, 0x74, - 0x4b, 0x69, 0x2a, 0xf4, 0x9e, 0x6e, 0x20, 0xf3, 0x42, 0x7c, 0x0b, 0xc6, 0x35, 0x83, 0x80, 0x21, - 0x9d, 0x5c, 0xbd, 0x90, 0xf5, 0x76, 0x99, 0xac, 0x21, 0x92, 0x49, 0xb3, 0x70, 0x99, 0x9c, 0x36, - 0x58, 0xe7, 0x61, 0xd1, 0x43, 0x3f, 0x87, 0xf8, 0x0b, 0x01, 0x16, 0x8a, 0xa4, 0xb6, 0x86, 0xa8, - 0x5c, 0x77, 0x23, 0x24, 0x9e, 0x48, 0xd7, 0x21, 0xce, 0xf4, 0x91, 0xd4, 0x68, 0x66, 0x6c, 0x58, - 0xa8, 0x16, 0xab, 0x0d, 0xeb, 0x25, 0xb8, 0x30, 0x10, 0x07, 0x47, 0xfc, 0xf9, 0x28, 0x48, 0x45, - 0x52, 0x2b, 0xa8, 0x84, 0x22, 0x95, 0x1a, 0x54, 0x45, 0xa4, 0xef, 0x61, 0xba, 0x85, 0xda, 0xaa, - 0x5c, 0xf7, 0x84, 0x3b, 0x0f, 0x71, 0xaa, 0xc8, 0x7b, 0x96, 0x65, 0x93, 0x25, 0xeb, 0x49, 0x5c, - 0x00, 0x30, 0xf6, 0xb9, 0x52, 0xc5, 0xaa, 0xd6, 0x64, 0x1e, 0x90, 0x2c, 0x25, 0x8d, 0x91, 0x0d, - 0x63, 0x40, 0x5c, 0x84, 0xc9, 0x07, 0x6d, 0x8d, 0x76, 0xe6, 0x63, 0x6c, 0x1e, 0xd8, 0x90, 0x49, - 0xf0, 0x03, 0x38, 0xd9, 0x54, 0xd4, 0x4a, 0x4b, 0x57, 0x64, 0x5c, 0x31, 0x64, 0x56, 0x88, 0xf2, - 0x21, 0x4e, 0x8d, 0x1b, 0x84, 0x6b, 0x59, 0x63, 0xb1, 0x9f, 0x7f, 0xb1, 0x78, 0xb1, 0xa6, 0xd0, - 0x7a, 0x7b, 0x37, 0x2b, 0x6b, 0xcd, 0x9c, 0x15, 0x7f, 0xe6, 0x9f, 0x2b, 0xa4, 0xba, 0x97, 0xa3, - 0x07, 0x2d, 0x4c, 0xb2, 0x1b, 0x58, 0x2e, 0xcd, 0x36, 0x15, 0x75, 0xdb, 0x90, 0xb4, 0xa3, 0xc8, - 0x7b, 0x65, 0xe5, 0x43, 0x2c, 0xca, 0x30, 0x6f, 0x88, 0x7f, 0xd0, 0x46, 0x2a, 0x55, 0xe8, 0x81, - 0x4d, 0x43, 0x3c, 0x94, 0x06, 0x03, 0xec, 0x7b, 0x96, 0xb0, 0x8e, 0x12, 0xdb, 0x2e, 0xbc, 0x0e, - 0x4b, 0xde, 0xb6, 0xe5, 0x5b, 0xf0, 0xdf, 0x38, 0x73, 0x2c, 0x8b, 0x6c, 0x1b, 0xeb, 0x2d, 0x4c, - 0xdb, 0xa8, 0x71, 0xa8, 0x7d, 0x70, 0x18, 0x7a, 0xac, 0xcf, 0xd0, 0x8b, 0x30, 0x69, 0x9e, 0x79, - 0x15, 0x63, 0x77, 0x3a, 0x3b, 0x61, 0x0e, 0xad, 0x21, 0x82, 0xc5, 0xf3, 0x30, 0x65, 0x11, 0x30, - 0x2e, 0x73, 0x0b, 0x4a, 0x16, 0xd3, 0x7b, 0xc6, 0x90, 0x98, 0x85, 0x93, 0x16, 0x09, 0x91, 0x51, - 0x03, 0x57, 0xee, 0x23, 0x99, 0x6a, 0x3a, 0x33, 0xe5, 0x74, 0xe9, 0x35, 0x73, 0xaa, 0x6c, 0xcc, - 0x6c, 0xb2, 0x09, 0x31, 0xcf, 0x75, 0x1a, 0x16, 0x4c, 0x25, 0x32, 0xc2, 0xca, 0xcc, 0xea, 0xeb, - 0x36, 0x47, 0xb7, 0x4e, 0xe1, 0x8e, 0x9b, 0xdf, 0x63, 0x8f, 0x3b, 0x07, 0x2d, 0xdc, 0x41, 0x66, - 0xfc, 0x16, 0x77, 0x60, 0xa6, 0x89, 0xf6, 0xb0, 0x5e, 0xb9, 0x8f, 0x71, 0x45, 0x47, 0x14, 0xa7, - 0x26, 0x42, 0x6d, 0xde, 0x14, 0x93, 0xb2, 0x89, 0x71, 0x09, 0x51, 0x26, 0x95, 0xf6, 0x4a, 0x4d, - 0x86, 0x93, 0x4a, 0xed, 0x52, 0x7f, 0x04, 0x73, 0x8a, 0xaa, 0x50, 0x05, 0x35, 0x2a, 0x4d, 0xa4, - 0xd7, 0x14, 0xd5, 0x10, 0xad, 0x68, 0x29, 0x08, 0x25, 0x5b, 0xb4, 0x64, 0x15, 0x99, 0xa8, 0x92, - 0x21, 0x49, 0xac, 0x43, 0xaa, 0x89, 0x14, 0x95, 0x62, 0x15, 0xa9, 0x32, 0xee, 0xd5, 0x32, 0x19, - 0x4a, 0xcb, 0xbc, 0x4d, 0x9e, 0x5d, 0x93, 0x47, 0x6c, 0x4e, 0x45, 0x1e, 0x9b, 0xd3, 0x51, 0xc4, - 0xe6, 0x1b, 0x70, 0xc9, 0x27, 0xe8, 0x78, 0x80, 0xfe, 0x26, 0x01, 0xcb, 0x5d, 0xda, 0xfc, 0x7e, - 0x4b, 0xd1, 0x0f, 0x36, 0xdb, 0xb4, 0xad, 0x63, 0xf2, 0xf2, 0x07, 0xa9, 0x23, 0xe8, 0xe2, 0x21, - 0x83, 0xce, 0x23, 0xd6, 0x13, 0x5e, 0xb1, 0x3e, 0x0f, 0x71, 0xcc, 0x0c, 0xc5, 0x82, 0x73, 0xac, - 0x64, 0x3d, 0xb9, 0x04, 0x6f, 0x32, 0x92, 0xe0, 0x85, 0x08, 0x83, 0x77, 0xf2, 0x58, 0x82, 0x77, - 0xea, 0x38, 0x82, 0x77, 0x3a, 0xf2, 0xe0, 0x9d, 0x89, 0x22, 0x78, 0xaf, 0xc0, 0xe5, 0x00, 0x01, - 0xc9, 0x03, 0xf8, 0x11, 0xa4, 0x7a, 0x6e, 0x6e, 0x26, 0xd1, 0x31, 0x5e, 0x1d, 0x97, 0x20, 0xe3, - 0x05, 0xc0, 0x79, 0x77, 0x34, 0x89, 0x36, 0xb0, 0xae, 0x3c, 0x44, 0x86, 0xb6, 0x00, 0xb7, 0xdc, - 0xdb, 0xbd, 0x50, 0x2f, 0x0f, 0x82, 0xda, 0x15, 0xec, 0x02, 0x38, 0xf6, 0xb8, 0x7b, 0x77, 0xf4, - 0xc6, 0xc1, 0x11, 0x7f, 0x2c, 0xb0, 0x73, 0xd1, 0x76, 0xcb, 0x74, 0x23, 0xf7, 0xbe, 0xf3, 0x16, - 0x1c, 0x77, 0xde, 0x10, 0xc0, 0x3b, 0x37, 0x5f, 0x13, 0xb9, 0xe9, 0x16, 0x7e, 0x78, 0x38, 0xfe, - 0xdf, 0x09, 0x2c, 0x1d, 0x5a, 0x37, 0x62, 0xa5, 0xc1, 0xf7, 0xd0, 0x13, 0xee, 0x59, 0x48, 0x36, - 0xd9, 0xbe, 0x75, 0x53, 0x9f, 0x09, 0x73, 0xa0, 0x50, 0xed, 0xcf, 0x8d, 0xc6, 0x5c, 0x72, 0xa3, - 0x05, 0x00, 0x86, 0xb7, 0x52, 0x47, 0xa4, 0x6e, 0x1d, 0xe7, 0x49, 0x36, 0x72, 0x07, 0x91, 0xba, - 0xb5, 0x88, 0x73, 0xec, 0x42, 0xee, 0x00, 0xc5, 0x31, 0x1f, 0x30, 0x57, 0x36, 0x97, 0xd8, 0x4b, - 0xe2, 0x6d, 0xe7, 0x9b, 0x10, 0xab, 0x22, 0x8a, 0x82, 0x64, 0x16, 0x4c, 0xd2, 0x06, 0xa2, 0xc8, - 0xb2, 0x2f, 0x63, 0xb4, 0x80, 0x99, 0x4e, 0xec, 0xaa, 0x9a, 0xc3, 0xfb, 0xa5, 0x00, 0x69, 0x17, - 0xe7, 0x09, 0x12, 0x70, 0x47, 0xec, 0xc5, 0x2b, 0x70, 0x71, 0x30, 0x10, 0x8e, 0xf9, 0x0f, 0x82, - 0x79, 0x3c, 0xb0, 0x35, 0x39, 0x24, 0x7f, 0xd9, 0xce, 0x60, 0x1d, 0x1c, 0x6e, 0xd0, 0x38, 0xfe, - 0x06, 0x24, 0xf9, 0xb6, 0xf5, 0xe2, 0x12, 0xfc, 0x70, 0x8d, 0xfa, 0xe2, 0x1a, 0x73, 0xe0, 0x5a, - 0x7a, 0xc4, 0x36, 0xd8, 0xe6, 0x05, 0x0e, 0x58, 0x91, 0xbb, 0xa1, 0xb9, 0xb1, 0x03, 0x00, 0x70, - 0xc3, 0xfc, 0x53, 0x80, 0x53, 0x45, 0x52, 0x2b, 0xf3, 0xd5, 0xed, 0xe8, 0x48, 0x25, 0xf7, 0x07, - 0xec, 0xea, 0x9b, 0x30, 0x47, 0xb4, 0xb6, 0x2e, 0xe3, 0x8a, 0x9b, 0x9d, 0x44, 0x73, 0xae, 0x6c, - 0xb7, 0xd6, 0x0d, 0x38, 0x53, 0xc5, 0x84, 0x2a, 0xaa, 0xf1, 0x96, 0x55, 0x2b, 0x6e, 0xdb, 0x7e, - 0xda, 0x46, 0x50, 0x76, 0x2f, 0x95, 0xc4, 0x86, 0x2a, 0x95, 0x2c, 0x2d, 0xb2, 0x37, 0x45, 0xff, - 0xba, 0xf8, 0xca, 0xff, 0x21, 0xb0, 0x12, 0x4a, 0x7e, 0x9f, 0x62, 0x5d, 0x45, 0x8d, 0x57, 0x65, - 0xdd, 0x0b, 0x70, 0xd6, 0x65, 0x55, 0x7c, 0xd5, 0x7f, 0x17, 0x60, 0xae, 0x48, 0x6a, 0x5b, 0xca, - 0x83, 0xb6, 0x52, 0x45, 0x14, 0x6f, 0x6b, 0x44, 0x31, 0x94, 0x1f, 0xae, 0xa0, 0xd5, 0x13, 0x51, - 0x63, 0x8e, 0x88, 0xe2, 0x87, 0x56, 0x2c, 0xdc, 0xa1, 0x25, 0x58, 0x87, 0xd6, 0x52, 0x1a, 0xce, - 0xb9, 0x41, 0xef, 0xde, 0x0e, 0x46, 0xe1, 0x0c, 0xbb, 0xf2, 0xc8, 0x3a, 0x46, 0x84, 0xcf, 0x9b, - 0x57, 0xbc, 0x97, 0x64, 0x5f, 0x7b, 0x2c, 0x15, 0x73, 0x58, 0x6a, 0x93, 0x6f, 0x7a, 0xb8, 0x62, - 0x4e, 0xc7, 0x07, 0x96, 0xe1, 0xbc, 0xa7, 0x1d, 0xb8, 0xb5, 0x7e, 0x3f, 0x0e, 0x0b, 0xdd, 0x7b, - 0xd6, 0x36, 0xd2, 0x51, 0xf3, 0xfd, 0x16, 0xb3, 0xab, 0xae, 0xb5, 0x34, 0x82, 0x1a, 0xe2, 0x1c, - 0x8c, 0x53, 0x85, 0x36, 0xb0, 0x65, 0x30, 0xf3, 0x41, 0xcc, 0xc0, 0x64, 0x15, 0x13, 0x59, 0x57, - 0x5a, 0x86, 0x50, 0xcb, 0x4c, 0xf6, 0xa1, 0xc1, 0xde, 0xd0, 0x9f, 0xdc, 0xc4, 0xf8, 0x5a, 0x85, - 0x23, 0x4c, 0x6e, 0xc6, 0xc3, 0x49, 0xed, 0x49, 0x6e, 0x64, 0x98, 0xd7, 0x71, 0x03, 0x1d, 0x58, - 0x72, 0x49, 0x1d, 0xe9, 0x96, 0xf4, 0x78, 0x28, 0xe9, 0x27, 0x2d, 0x69, 0x9b, 0x18, 0x97, 0x0d, - 0x59, 0x4c, 0x89, 0x47, 0xd6, 0x91, 0x08, 0xa5, 0x61, 0x98, 0xac, 0x63, 0x22, 0xdc, 0x1a, 0x5c, - 0xb2, 0x0e, 0xf1, 0x3b, 0x10, 0x27, 0x14, 0xd1, 0x36, 0x61, 0x99, 0xea, 0xcc, 0xea, 0xca, 0xa0, - 0x18, 0x37, 0x1d, 0xae, 0xcc, 0xe8, 0x4b, 0x16, 0x9f, 0x2d, 0x0f, 0xf8, 0xb3, 0x00, 0xf3, 0x79, - 0x8b, 0x27, 0xaf, 0xa2, 0xdd, 0xc6, 0xe1, 0x1d, 0x72, 0x0b, 0xa6, 0x3a, 0x28, 0x8c, 0x44, 0x9d, - 0xf9, 0xa4, 0x0f, 0xc8, 0xbc, 0x8d, 0xbe, 0xd4, 0xc3, 0x6d, 0x83, 0xfa, 0xbf, 0x51, 0x48, 0x39, - 0x4b, 0x96, 0x87, 0x06, 0xdb, 0xad, 0x84, 0x8c, 0x0d, 0x28, 0x1b, 0xc7, 0x7c, 0xca, 0xc6, 0xe3, - 0x41, 0xcb, 0xc6, 0xf1, 0xc8, 0xb3, 0xdb, 0x44, 0x14, 0xd9, 0xed, 0x27, 0x09, 0x58, 0x70, 0xad, - 0x48, 0x45, 0x66, 0x7f, 0xdf, 0xba, 0xbc, 0xa3, 0x12, 0x35, 0xee, 0x5b, 0x89, 0x8a, 0x07, 0x2e, - 0x17, 0x27, 0x02, 0x96, 0x8b, 0x27, 0x42, 0x56, 0xae, 0xbc, 0xaa, 0x38, 0xc9, 0x63, 0xa9, 0xe2, - 0xc0, 0x91, 0x56, 0x71, 0xfa, 0x5f, 0x30, 0x93, 0x91, 0x54, 0xcf, 0xa6, 0x8e, 0xa0, 0x7a, 0xf6, - 0x6a, 0x55, 0x9c, 0xfe, 0x96, 0x80, 0xf3, 0x9e, 0x85, 0xa6, 0xaf, 0xe2, 0x32, 0x44, 0x5c, 0x76, - 0x2b, 0xc4, 0xc9, 0x9e, 0x0a, 0xf1, 0xab, 0xd4, 0x32, 0xe9, 0x8f, 0xd7, 0xa9, 0x48, 0xe2, 0x75, - 0x3a, 0xba, 0x78, 0x9d, 0x89, 0x3c, 0x5e, 0x4f, 0x44, 0x11, 0xaf, 0x7f, 0x99, 0x80, 0x65, 0x67, - 0xd9, 0xe7, 0xd8, 0xf2, 0x00, 0x2f, 0x17, 0x0e, 0x97, 0x0d, 0x0c, 0xeb, 0xc2, 0xe1, 0xb2, 0x83, - 0xe0, 0x2e, 0x1c, 0x8f, 0x24, 0xa7, 0x49, 0x44, 0x9a, 0xd3, 0x4c, 0x44, 0x9e, 0xd3, 0x24, 0x23, - 0xcf, 0x69, 0xe0, 0xe8, 0x72, 0x9a, 0x1f, 0x82, 0x78, 0x47, 0x6b, 0xeb, 0x8d, 0x83, 0x82, 0x4a, - 0xb1, 0x8e, 0x09, 0x2d, 0xf5, 0xde, 0x25, 0x86, 0x72, 0xcf, 0x7e, 0x49, 0xe2, 0x2e, 0xcc, 0x99, - 0xa3, 0x9b, 0x6d, 0xb5, 0xaa, 0xa8, 0x35, 0x63, 0x70, 0x1d, 0xb5, 0x6c, 0xa7, 0xdf, 0x30, 0x1a, - 0x5c, 0x65, 0xd9, 0xf2, 0xb2, 0xe9, 0x43, 0xe7, 0x65, 0x1f, 0x09, 0x70, 0xd9, 0x79, 0x5a, 0xac, - 0x21, 0xb5, 0x6a, 0xbe, 0xba, 0xb6, 0x75, 0xad, 0xa9, 0x19, 0x51, 0x1f, 0xe9, 0xa9, 0xd1, 0x85, - 0xf3, 0xb5, 0x7d, 0x98, 0xb2, 0xe7, 0x68, 0xe2, 0x2a, 0xcc, 0xe5, 0xbf, 0xb7, 0x7e, 0xe7, 0xd6, - 0xdd, 0xdb, 0xf9, 0xca, 0xfb, 0x77, 0xcb, 0xdb, 0xf9, 0xf5, 0xc2, 0x66, 0x21, 0xbf, 0x31, 0x3b, - 0x22, 0xa5, 0x9e, 0x3c, 0xcd, 0xb8, 0xce, 0x89, 0x22, 0xc4, 0xca, 0xdb, 0xf7, 0x76, 0x66, 0x05, - 0x69, 0xe2, 0xc9, 0xd3, 0x0c, 0xfb, 0x6d, 0x00, 0xdc, 0xc8, 0x97, 0x0a, 0x1f, 0xdc, 0xda, 0x29, - 0x7c, 0x90, 0x2f, 0xcf, 0x8e, 0x4a, 0x27, 0x9e, 0x3c, 0xcd, 0xd8, 0x87, 0x56, 0xff, 0x74, 0x0a, - 0xc6, 0x8a, 0xa4, 0x26, 0x22, 0x48, 0x74, 0xbe, 0x59, 0xbb, 0x38, 0xd0, 0xae, 0xfc, 0x6b, 0x32, - 0x29, 0x1b, 0x8c, 0xae, 0x53, 0xa3, 0x11, 0xab, 0x30, 0xc1, 0xbf, 0x38, 0xbb, 0xe4, 0xc3, 0xdb, - 0x21, 0x94, 0x72, 0x01, 0x09, 0xb9, 0x96, 0x4f, 0x04, 0x38, 0xed, 0xf5, 0x71, 0xd3, 0xdb, 0x3e, - 0xc2, 0x3c, 0xf8, 0xa4, 0x6f, 0x87, 0xe3, 0xe3, 0x98, 0x9e, 0x09, 0x70, 0x6e, 0xe0, 0xd7, 0x3e, - 0xef, 0x06, 0x53, 0xe0, 0xca, 0x2c, 0xad, 0x1f, 0x82, 0x99, 0x43, 0xfc, 0xab, 0x00, 0x19, 0xdf, - 0xef, 0x1d, 0x6e, 0x06, 0xd3, 0xe4, 0x29, 0x40, 0xba, 0x7d, 0x48, 0x01, 0x1c, 0xee, 0x63, 0x01, - 0xe6, 0x5c, 0x3f, 0x0c, 0x7c, 0xcb, 0x47, 0x83, 0x1b, 0x93, 0xf4, 0x6e, 0x08, 0x26, 0x0e, 0xe5, - 0x8f, 0x02, 0x48, 0x03, 0xbe, 0xff, 0xbb, 0xee, 0x23, 0xdb, 0x9b, 0x55, 0xba, 0x15, 0x9a, 0x95, - 0x83, 0xfb, 0x95, 0x00, 0xa7, 0xdc, 0xdb, 0xe0, 0xd7, 0x02, 0xaf, 0xd9, 0xc6, 0x25, 0x7d, 0x33, - 0x0c, 0x17, 0x47, 0x73, 0x00, 0x27, 0x9c, 0xbd, 0x57, 0xbf, 0x43, 0xc4, 0x41, 0x2f, 0xbd, 0x3d, - 0x1c, 0x7d, 0x8f, 0x21, 0xdc, 0x9b, 0xa8, 0xd7, 0x02, 0x59, 0xd9, 0xc1, 0xe5, 0x6b, 0x88, 0x81, - 0x5d, 0x53, 0xe6, 0x33, 0x03, 0xfa, 0xfe, 0xd7, 0x03, 0x59, 0xd9, 0x8d, 0xd5, 0xd7, 0x67, 0xfc, - 0xbb, 0xfc, 0xec, 0x28, 0xf0, 0x6d, 0xf1, 0xdf, 0x0c, 0xee, 0x9b, 0xae, 0x02, 0x7c, 0x8f, 0x82, - 0xa0, 0x4d, 0x7d, 0xf1, 0xa9, 0x00, 0x67, 0x07, 0xb5, 0x9f, 0x6f, 0x0c, 0x69, 0x11, 0xbb, 0xbb, - 0xaf, 0x85, 0xe7, 0xed, 0x0d, 0x41, 0xd7, 0x56, 0xf3, 0xb5, 0x40, 0xbe, 0xec, 0xe0, 0xf2, 0x0f, - 0xc1, 0x41, 0xbd, 0x63, 0x66, 0xad, 0x41, 0xbd, 0xdc, 0x1b, 0xc1, 0xfd, 0xda, 0xc9, 0xeb, 0x6b, - 0xad, 0x00, 0x2d, 0x5c, 0xf1, 0xe7, 0x02, 0x88, 0x2e, 0xfd, 0xdb, 0xab, 0x3e, 0xa2, 0xfb, 0x59, - 0xa4, 0xeb, 0x43, 0xb3, 0x70, 0x10, 0x3f, 0x85, 0xd9, 0xbe, 0x4e, 0xaa, 0xdf, 0x45, 0xc4, 0xc9, - 0x20, 0xbd, 0x33, 0x24, 0x03, 0xd7, 0xfe, 0x08, 0x5e, 0xeb, 0xef, 0x68, 0xbe, 0xe9, 0x23, 0xad, - 0x8f, 0x43, 0xfa, 0xc6, 0xb0, 0x1c, 0x1c, 0xc0, 0xc7, 0x02, 0xcc, 0x7b, 0xf4, 0x1d, 0xbf, 0xee, - 0xfb, 0x02, 0x77, 0x63, 0x93, 0xbe, 0x15, 0x8a, 0xad, 0x03, 0x68, 0xad, 0xfe, 0xe9, 0xf3, 0xb4, - 0xf0, 0xd9, 0xf3, 0xb4, 0xf0, 0xef, 0xe7, 0x69, 0xe1, 0xb7, 0x2f, 0xd2, 0x23, 0x9f, 0xbd, 0x48, - 0x8f, 0xfc, 0xeb, 0x45, 0x7a, 0xe4, 0xfb, 0x77, 0x6d, 0x19, 0x45, 0xa1, 0xa3, 0x62, 0x0b, 0xed, - 0x92, 0x1c, 0x57, 0x78, 0x45, 0xd6, 0x74, 0x6c, 0x7f, 0xac, 0x23, 0x45, 0xcd, 0x35, 0xb5, 0x6a, - 0xbb, 0x81, 0x49, 0xf7, 0xff, 0x3d, 0x58, 0xf6, 0xb1, 0x1b, 0x67, 0xff, 0xc5, 0xf1, 0xd6, 0xff, - 0x03, 0x00, 0x00, 0xff, 0xff, 0x86, 0xa1, 0x2c, 0xfc, 0x90, 0x32, 0x00, 0x00, + // 2282 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0xcf, 0x6f, 0x1b, 0xc7, + 0x15, 0xd6, 0x8a, 0x14, 0x7f, 0x3c, 0x4a, 0x8e, 0xb3, 0x96, 0x65, 0x7a, 0x6d, 0x4b, 0xb4, 0x1c, + 0x3b, 0x4a, 0x0d, 0x93, 0xb1, 0xec, 0x26, 0xb5, 0xd3, 0xd6, 0xb5, 0x24, 0xca, 0x66, 0x21, 0xda, + 0x0a, 0xa9, 0xa4, 0x45, 0x80, 0x96, 0x1d, 0x2d, 0xc7, 0xe4, 0xd6, 0xe4, 0x2e, 0xbd, 0x33, 0x74, + 0xc5, 0xa0, 0xa8, 0x81, 0x1e, 0xda, 0xc0, 0x4d, 0xd3, 0x06, 0x45, 0x0f, 0x2d, 0x60, 0xc0, 0xe8, + 0xa9, 0x40, 0xdb, 0x5b, 0x2f, 0xfd, 0x0f, 0x72, 0xcc, 0xa1, 0x28, 0x8a, 0x1c, 0x82, 0xc2, 0xbe, + 0xf4, 0xde, 0x4b, 0x8f, 0xc5, 0xce, 0x2e, 0x87, 0xcb, 0xe5, 0x2e, 0x77, 0xb9, 0xd2, 0x2a, 0x81, + 0xd1, 0x93, 0xb5, 0xbb, 0xef, 0x7d, 0xef, 0x9b, 0x37, 0xef, 0x0d, 0xe7, 0xbd, 0x19, 0xc3, 0x39, + 0x45, 0xfd, 0x21, 0x96, 0xa9, 0xf2, 0x10, 0x17, 0xf0, 0x9e, 0xdc, 0x44, 0x6a, 0x03, 0x17, 0x1e, + 0x5e, 0xde, 0xc5, 0x14, 0x5d, 0x2e, 0xd0, 0xbd, 0x7c, 0x47, 0xd7, 0xa8, 0x26, 0x4a, 0x5c, 0x28, + 0xdf, 0x17, 0xca, 0x5b, 0x42, 0xd2, 0x7c, 0x43, 0x6b, 0x68, 0x4c, 0xac, 0x60, 0xfc, 0x65, 0x6a, + 0x48, 0xe7, 0x07, 0xb0, 0x9a, 0x8e, 0xe4, 0xd6, 0x00, 0xd4, 0x7c, 0xb4, 0xc4, 0x5e, 0x1b, 0x63, + 0x9d, 0x5b, 0x32, 0x45, 0x17, 0x65, 0x8d, 0xb4, 0x35, 0x52, 0xd8, 0x45, 0x64, 0x20, 0x23, 0x6b, + 0x8a, 0x6a, 0x7e, 0x5f, 0xfe, 0x50, 0x00, 0x28, 0x93, 0xc6, 0x06, 0xee, 0x68, 0x44, 0xa1, 0xe2, + 0x02, 0x24, 0x08, 0x56, 0xeb, 0x58, 0xcf, 0x0a, 0x39, 0x61, 0x25, 0x5d, 0xb1, 0x9e, 0xc4, 0x73, + 0x30, 0x47, 0xba, 0xbb, 0x48, 0x96, 0xb5, 0xae, 0x4a, 0x6b, 0x4a, 0x3d, 0x3b, 0xcd, 0x3e, 0xcf, + 0x0e, 0x5e, 0x96, 0xea, 0xe2, 0x9b, 0x90, 0x40, 0x6d, 0xe3, 0xef, 0x6c, 0x2c, 0x27, 0xac, 0x64, + 0x56, 0x4f, 0xe6, 0x4d, 0xe3, 0x79, 0xc3, 0x78, 0x7f, 0xe4, 0xf9, 0x75, 0x4d, 0x51, 0xd7, 0xe2, + 0x9f, 0x7c, 0xbe, 0x34, 0x55, 0xb1, 0xc4, 0xaf, 0xa7, 0x3e, 0x78, 0xba, 0x34, 0xf5, 0xef, 0xa7, + 0x4b, 0x53, 0xcb, 0xf3, 0x20, 0x0e, 0xd8, 0x54, 0x30, 0xe9, 0x68, 0x2a, 0xc1, 0xcb, 0xbf, 0x14, + 0x20, 0x53, 0x26, 0x8d, 0xef, 0x28, 0xb4, 0x59, 0xd7, 0xd1, 0x8f, 0xbe, 0x70, 0x96, 0xc7, 0xe1, + 0x98, 0x8d, 0x0e, 0xa7, 0xf9, 0x13, 0x38, 0x51, 0x26, 0x8d, 0x75, 0x1d, 0x23, 0x8a, 0xab, 0x1d, + 0x8d, 0x6e, 0x29, 0x6d, 0x85, 0xde, 0xd5, 0x0d, 0x66, 0x5e, 0x8c, 0x6f, 0xc2, 0x8c, 0x66, 0x08, + 0x30, 0xa6, 0x99, 0xd5, 0xf3, 0x79, 0xef, 0x90, 0xc9, 0x1b, 0x90, 0x0c, 0xcd, 0xe2, 0x65, 0x6a, + 0xda, 0x68, 0x7d, 0x1b, 0x96, 0x3c, 0xec, 0xf7, 0x29, 0x8a, 0x67, 0x00, 0x98, 0x56, 0xad, 0x89, + 0x48, 0xd3, 0xe2, 0x92, 0x66, 0x6f, 0x6e, 0x23, 0xd2, 0xb4, 0x61, 0xfd, 0x4c, 0x80, 0x33, 0x65, + 0xd2, 0x58, 0x43, 0x54, 0x6e, 0xba, 0x21, 0x12, 0xcf, 0x21, 0xad, 0x43, 0x82, 0x01, 0x92, 0xec, + 0x74, 0x2e, 0x36, 0xe9, 0x98, 0x2c, 0x55, 0x1b, 0x91, 0x1d, 0x38, 0x3f, 0x96, 0x07, 0x1f, 0xda, + 0x59, 0x98, 0x1d, 0x0c, 0x0d, 0x93, 0xac, 0x90, 0x8b, 0xad, 0xa4, 0x2b, 0x19, 0x3e, 0x38, 0x6c, + 0x47, 0xfd, 0x6c, 0x1a, 0xa4, 0x32, 0x69, 0x94, 0x54, 0x42, 0x91, 0x4a, 0x0d, 0xc8, 0x32, 0xd2, + 0xef, 0x63, 0xba, 0x85, 0xba, 0xaa, 0xdc, 0xf4, 0x1c, 0xdb, 0x02, 0x24, 0xa8, 0x22, 0xdf, 0xb7, + 0xe6, 0x2b, 0x5d, 0xb1, 0x9e, 0x0c, 0xb7, 0x1a, 0xd1, 0x53, 0xab, 0x63, 0x55, 0x6b, 0xb3, 0xb8, + 0x4a, 0x57, 0xd2, 0xc6, 0x9b, 0x0d, 0xe3, 0x85, 0xb8, 0x04, 0x99, 0x07, 0x5d, 0x8d, 0xf6, 0xbf, + 0xc7, 0xd9, 0x77, 0x60, 0xaf, 0x4c, 0x81, 0xef, 0xc1, 0xb1, 0xb6, 0xa2, 0xd6, 0x3a, 0xba, 0x22, + 0xe3, 0x9a, 0x81, 0x59, 0x23, 0xca, 0xfb, 0x38, 0x3b, 0x63, 0x08, 0xae, 0xe5, 0x0d, 0xcf, 0x7c, + 0xf6, 0xf9, 0xd2, 0x85, 0x86, 0x42, 0x9b, 0xdd, 0xdd, 0xbc, 0xac, 0xb5, 0x0b, 0x56, 0x56, 0x9b, + 0xff, 0x5c, 0x22, 0xf5, 0xfb, 0x05, 0xda, 0xeb, 0x60, 0x92, 0xdf, 0xc0, 0x72, 0xe5, 0x68, 0x5b, + 0x51, 0xb7, 0x0d, 0xa4, 0x1d, 0x45, 0xbe, 0x5f, 0x55, 0xde, 0xc7, 0xa2, 0x0c, 0x0b, 0x06, 0xfc, + 0x83, 0x2e, 0x52, 0xa9, 0x42, 0x7b, 0x36, 0x0b, 0x89, 0x50, 0x16, 0x0c, 0xb2, 0x6f, 0x5b, 0x60, + 0x7d, 0x23, 0x36, 0xe7, 0xbe, 0x02, 0xcb, 0xde, 0xbe, 0xe5, 0xd9, 0xf2, 0x9f, 0x04, 0x0b, 0x57, + 0x4b, 0x6c, 0x1b, 0xeb, 0x1d, 0x4c, 0xbb, 0xa8, 0xb5, 0xaf, 0x79, 0x70, 0x38, 0x3a, 0x36, 0xe2, + 0xe8, 0x25, 0xc8, 0x98, 0x2b, 0x69, 0xcd, 0x98, 0x9d, 0xfe, 0x4c, 0x98, 0xaf, 0xd6, 0x50, 0x3f, + 0x8a, 0x98, 0x00, 0xd3, 0x32, 0xa7, 0xa0, 0x62, 0x29, 0xbd, 0x6d, 0xbc, 0x12, 0xf3, 0x70, 0xcc, + 0x12, 0x21, 0x32, 0x6a, 0xe1, 0xda, 0x3d, 0x24, 0x53, 0x4d, 0x67, 0xae, 0x9c, 0xab, 0xbc, 0x6c, + 0x7e, 0xaa, 0x1a, 0x5f, 0x36, 0xd9, 0x07, 0xb1, 0xc8, 0x6d, 0x1a, 0x1e, 0xcc, 0x26, 0x73, 0xc2, + 0xca, 0x91, 0xd5, 0x57, 0x6c, 0x59, 0x61, 0xad, 0xed, 0xfd, 0x9c, 0xb8, 0xcb, 0x1e, 0x77, 0x7a, + 0x1d, 0xdc, 0x67, 0x66, 0xfc, 0x2d, 0xee, 0xc0, 0x91, 0x36, 0xba, 0x8f, 0xf5, 0xda, 0x3d, 0x8c, + 0x6b, 0x3a, 0xa2, 0x38, 0x9b, 0x0a, 0x35, 0x79, 0xb3, 0x0c, 0x65, 0x13, 0xe3, 0x0a, 0xa2, 0x0c, + 0x95, 0x0e, 0xa3, 0xa6, 0xc3, 0xa1, 0x52, 0x3b, 0xea, 0x0f, 0x60, 0x5e, 0x51, 0x15, 0xaa, 0xa0, + 0x56, 0xad, 0x8d, 0xf4, 0x86, 0xa2, 0x1a, 0xd0, 0x8a, 0x96, 0x85, 0x50, 0xd8, 0xa2, 0x85, 0x55, + 0x66, 0x50, 0x15, 0x03, 0x49, 0x6c, 0x42, 0xb6, 0x8d, 0x14, 0x95, 0x62, 0x15, 0xa9, 0x32, 0x1e, + 0xb6, 0x92, 0x09, 0x65, 0x65, 0xc1, 0x86, 0x67, 0xb7, 0xe4, 0x91, 0x9b, 0xb3, 0x91, 0xe7, 0xe6, + 0x5c, 0x14, 0xb9, 0xf9, 0x1a, 0xbc, 0xea, 0x93, 0x74, 0x3c, 0x41, 0x7f, 0x95, 0x84, 0x73, 0x03, + 0xd9, 0xe2, 0x5e, 0x47, 0xd1, 0x7b, 0x9b, 0x5d, 0xda, 0xd5, 0x31, 0xf9, 0xf2, 0x27, 0xa9, 0x23, + 0xe9, 0x12, 0x21, 0x93, 0xce, 0x23, 0xd7, 0x93, 0x5e, 0xb9, 0xbe, 0x00, 0x09, 0xcc, 0x1c, 0xc5, + 0x92, 0x33, 0x56, 0xb1, 0x9e, 0x5c, 0x92, 0x37, 0x1d, 0x49, 0xf2, 0x42, 0x84, 0xc9, 0x9b, 0x39, + 0x94, 0xe4, 0x9d, 0x3d, 0x8c, 0xe4, 0x9d, 0x8b, 0x3c, 0x79, 0x8f, 0x44, 0x91, 0xbc, 0x97, 0xe0, + 0x62, 0x80, 0x84, 0xe4, 0x09, 0xfc, 0x08, 0xb2, 0x43, 0xfb, 0x41, 0x53, 0xe8, 0x10, 0x37, 0xa4, + 0xcb, 0x90, 0xf3, 0x22, 0xc0, 0x49, 0x5a, 0x1b, 0x4d, 0x53, 0x68, 0x03, 0xeb, 0xca, 0x43, 0x64, + 0x58, 0x0b, 0xb0, 0x77, 0xbe, 0x35, 0x4c, 0xf5, 0xe2, 0x38, 0xaa, 0x03, 0x60, 0x17, 0xc2, 0x71, + 0x83, 0xf0, 0xf2, 0x36, 0xdb, 0x68, 0x7a, 0xf3, 0x98, 0x7c, 0x0f, 0xfd, 0x91, 0xc0, 0x16, 0x50, + 0xdb, 0xde, 0xd5, 0x0d, 0xd7, 0x7b, 0x27, 0x5d, 0x72, 0xec, 0xa4, 0x43, 0x8c, 0xb0, 0xbf, 0x9f, + 0x36, 0x87, 0xf8, 0x1e, 0x8b, 0x1f, 0x3f, 0x3e, 0xe1, 0x76, 0xd4, 0xbf, 0x11, 0x58, 0xe9, 0xb6, + 0x6e, 0x64, 0x60, 0x8b, 0x47, 0x86, 0xe7, 0xd8, 0x4e, 0x41, 0xba, 0xcd, 0xa2, 0x61, 0x50, 0xa6, + 0xa5, 0xcc, 0x17, 0xa5, 0xfa, 0x68, 0x1d, 0x17, 0x73, 0xa9, 0xe3, 0x86, 0xa7, 0x21, 0xee, 0x9c, + 0x06, 0x73, 0xc4, 0xa7, 0xd9, 0x36, 0xdf, 0x41, 0x8a, 0xc7, 0x5e, 0x8f, 0x25, 0x88, 0xe9, 0x8f, + 0x61, 0x11, 0xef, 0x49, 0xb9, 0x01, 0xf1, 0x3a, 0xa2, 0x28, 0x48, 0x71, 0xc3, 0x90, 0x36, 0x10, + 0x45, 0xd6, 0x64, 0x30, 0x45, 0x8b, 0xd8, 0x26, 0x4b, 0x0d, 0x57, 0xd3, 0xdc, 0xff, 0x59, 0x48, + 0x92, 0xae, 0x2c, 0x63, 0x62, 0xba, 0x3e, 0x55, 0xe9, 0x3f, 0xda, 0xdc, 0xfe, 0x73, 0x01, 0x16, + 0x5d, 0xc2, 0x36, 0x48, 0xaa, 0x1f, 0x70, 0xfe, 0xac, 0xc0, 0x85, 0xf1, 0x44, 0xb8, 0xdb, 0x7f, + 0x27, 0x98, 0x0b, 0x13, 0x1b, 0xb7, 0x03, 0xf9, 0x8b, 0x0e, 0x18, 0x6b, 0xc9, 0x72, 0xa3, 0xc6, + 0xf9, 0xb7, 0x20, 0xcd, 0xa7, 0x76, 0x98, 0x97, 0xe0, 0xc7, 0x6b, 0xda, 0x97, 0x57, 0xcc, 0xc1, + 0x6b, 0xf9, 0x11, 0x9b, 0x60, 0x5b, 0xa4, 0x38, 0x68, 0x45, 0x1e, 0xaa, 0x5b, 0x6c, 0x62, 0xc7, + 0x10, 0x98, 0x28, 0x60, 0xff, 0x21, 0xc0, 0xf1, 0x32, 0x69, 0x54, 0xb9, 0x07, 0x76, 0x74, 0xa4, + 0x92, 0x7b, 0x63, 0x66, 0xfe, 0x75, 0x98, 0x27, 0x5a, 0x57, 0x97, 0x71, 0xcd, 0xcd, 0x97, 0xa2, + 0xf9, 0xad, 0x6a, 0xf7, 0xe8, 0x75, 0x38, 0x59, 0xc7, 0x84, 0x2a, 0xaa, 0xb1, 0x07, 0x50, 0x6b, + 0x6e, 0xa1, 0x71, 0xc2, 0x26, 0x50, 0x75, 0x6f, 0x0f, 0xc5, 0x27, 0x6a, 0x0f, 0x2d, 0x2f, 0xb1, + 0xdf, 0xb1, 0xd1, 0x71, 0xf1, 0xb0, 0xf9, 0xbb, 0xc0, 0xda, 0x46, 0xc5, 0x3d, 0x8a, 0x75, 0x15, + 0xb5, 0x5e, 0x94, 0x71, 0x9f, 0x81, 0x53, 0x2e, 0xa3, 0xe2, 0xa3, 0xfe, 0x9b, 0x00, 0xf3, 0x65, + 0xd2, 0xd8, 0x52, 0x1e, 0x74, 0x95, 0x3a, 0xa2, 0x78, 0x5b, 0x23, 0x8a, 0x61, 0x7c, 0x7f, 0x4d, + 0xbc, 0xa1, 0xac, 0x8b, 0x39, 0xb2, 0x8e, 0x2f, 0x6c, 0xf1, 0x70, 0x0b, 0x9b, 0x60, 0x2d, 0x6c, + 0xcb, 0x8b, 0x70, 0xda, 0x8d, 0xfa, 0x60, 0xef, 0x32, 0x0d, 0x27, 0xd9, 0x86, 0x4c, 0xd6, 0x31, + 0x22, 0xfc, 0xbb, 0xb9, 0x01, 0xfd, 0x92, 0xcc, 0xeb, 0x90, 0xa7, 0xe2, 0x0e, 0x4f, 0x6d, 0xf2, + 0x49, 0x0f, 0xd7, 0x6a, 0xea, 0xc7, 0xc0, 0x39, 0x38, 0xeb, 0xe9, 0x07, 0xee, 0xad, 0xdf, 0xce, + 0xc0, 0x99, 0xc1, 0x2e, 0x70, 0x1b, 0xe9, 0xa8, 0xfd, 0x4e, 0x87, 0xf9, 0x55, 0xd7, 0x3a, 0x1a, + 0x41, 0x2d, 0x71, 0x1e, 0x66, 0xa8, 0x42, 0x5b, 0xd8, 0x72, 0x98, 0xf9, 0x20, 0xe6, 0x20, 0x53, + 0xc7, 0x44, 0xd6, 0x95, 0x8e, 0x01, 0x6a, 0xb9, 0xc9, 0xfe, 0x6a, 0x7c, 0x34, 0x8c, 0x96, 0x5e, + 0x71, 0x3e, 0x56, 0xe1, 0x00, 0x4b, 0xaf, 0x99, 0x70, 0xa8, 0x43, 0xa5, 0x97, 0x0c, 0x0b, 0x3a, + 0x6e, 0xa1, 0x9e, 0x85, 0x4b, 0x9a, 0x48, 0xb7, 0xd0, 0x13, 0xa1, 0xd0, 0x8f, 0x59, 0x68, 0x9b, + 0x18, 0x57, 0x0d, 0x2c, 0x66, 0xc4, 0xa3, 0x26, 0x4a, 0x86, 0xb2, 0x30, 0x49, 0x4d, 0x94, 0x0a, + 0x37, 0x06, 0x97, 0x9a, 0x48, 0xfc, 0x16, 0x24, 0x08, 0x45, 0xb4, 0x4b, 0x58, 0x1d, 0x7d, 0x64, + 0x75, 0x65, 0x5c, 0x8e, 0x9b, 0x01, 0x57, 0x65, 0xf2, 0x15, 0x4b, 0xcf, 0xf6, 0x8b, 0xf4, 0x47, + 0x01, 0x16, 0x8a, 0x96, 0x4e, 0x51, 0x45, 0xbb, 0xad, 0xfd, 0x07, 0xe4, 0x16, 0xcc, 0xf6, 0x59, + 0xec, 0xf4, 0x3a, 0x98, 0xc5, 0xa4, 0x0f, 0xc9, 0xa2, 0x4d, 0xbe, 0x32, 0xa4, 0x6d, 0xa3, 0xfa, + 0xdf, 0x69, 0xc8, 0x3a, 0x1b, 0xaa, 0xfb, 0x26, 0x3b, 0xe8, 0xd3, 0xc4, 0xc6, 0x34, 0xb5, 0xe3, + 0x3e, 0x4d, 0xed, 0x99, 0xa0, 0x4d, 0xed, 0x44, 0xe4, 0xb5, 0x77, 0x32, 0x8a, 0xda, 0xfb, 0xe3, + 0x24, 0x9c, 0x71, 0xed, 0x97, 0x45, 0xe6, 0x7f, 0xdf, 0x53, 0x03, 0x47, 0x9f, 0x6c, 0xc6, 0xb7, + 0x4f, 0x96, 0x08, 0xdc, 0xcc, 0x4e, 0x06, 0x6c, 0x66, 0xa7, 0x42, 0xf6, 0xd5, 0xbc, 0x7a, 0x4c, + 0xe9, 0x43, 0xe9, 0x31, 0xc1, 0x81, 0xf6, 0x98, 0x46, 0x7f, 0x60, 0x32, 0x91, 0xf4, 0xf6, 0x66, + 0x0f, 0xa0, 0xb7, 0xf7, 0x62, 0xf5, 0xc3, 0xfe, 0x92, 0x84, 0xb3, 0x9e, 0x6d, 0xb0, 0xff, 0xe7, + 0x65, 0x88, 0xbc, 0x1c, 0xf4, 0xaf, 0xd3, 0x43, 0xfd, 0xeb, 0x17, 0xe9, 0x40, 0x67, 0x34, 0x5f, + 0x67, 0x23, 0xc9, 0xd7, 0xb9, 0xe8, 0xf2, 0xf5, 0x48, 0xe4, 0xf9, 0xfa, 0x52, 0x14, 0xf9, 0xfa, + 0xa7, 0x14, 0x9c, 0x73, 0xb6, 0x86, 0x0e, 0xad, 0x0e, 0xf0, 0x0a, 0xe1, 0x70, 0xd5, 0xc0, 0xa4, + 0x21, 0x1c, 0xae, 0x3a, 0x08, 0x1e, 0xc2, 0x89, 0x48, 0x6a, 0x9a, 0x64, 0xa4, 0x35, 0x4d, 0x2a, + 0xf2, 0x9a, 0x26, 0x1d, 0x79, 0x4d, 0x03, 0x07, 0x57, 0xd3, 0x7c, 0x1f, 0xc4, 0xdb, 0x5a, 0x57, + 0x6f, 0xf5, 0x4a, 0x2a, 0xc5, 0x3a, 0x26, 0xb4, 0x32, 0xbc, 0x97, 0x98, 0x28, 0x3c, 0x47, 0x91, + 0xc4, 0x5d, 0x98, 0x37, 0xdf, 0x6e, 0x76, 0xd5, 0xba, 0xa2, 0x36, 0x8c, 0x97, 0xeb, 0xa8, 0x63, + 0x5b, 0xfd, 0x26, 0xb1, 0xe0, 0x8a, 0x65, 0xab, 0xcb, 0xe6, 0xf6, 0x5d, 0x97, 0x7d, 0x28, 0xc0, + 0x45, 0xe7, 0x6a, 0xb1, 0x86, 0xd4, 0xba, 0xf9, 0xd3, 0xb5, 0xad, 0x6b, 0x6d, 0xcd, 0xc8, 0xfa, + 0x48, 0x57, 0x0d, 0x1b, 0x9d, 0xbf, 0x0a, 0xb0, 0x64, 0xb6, 0x82, 0x14, 0xda, 0x2b, 0x2b, 0xaa, + 0xa2, 0x36, 0xd6, 0x51, 0xbb, 0x83, 0x94, 0xc6, 0xfe, 0x29, 0xdc, 0x85, 0x94, 0x6c, 0x61, 0x59, + 0xb7, 0xd2, 0xae, 0x8c, 0x73, 0x9c, 0x07, 0x8d, 0x0a, 0x07, 0x19, 0xd0, 0xfe, 0xca, 0x1e, 0xcc, + 0xda, 0x4b, 0x4b, 0x71, 0x15, 0xe6, 0x8b, 0xdf, 0x5d, 0xbf, 0x7d, 0xf3, 0xce, 0xad, 0x62, 0xed, + 0x9d, 0x3b, 0xd5, 0xed, 0xe2, 0x7a, 0x69, 0xb3, 0x54, 0xdc, 0x38, 0x3a, 0x25, 0x65, 0x1f, 0x3f, + 0xc9, 0xb9, 0x7e, 0x13, 0x45, 0x88, 0x57, 0xb7, 0xef, 0xee, 0x1c, 0x15, 0xa4, 0xd4, 0xe3, 0x27, + 0x39, 0xf6, 0xb7, 0x31, 0xa8, 0x8d, 0x62, 0xa5, 0xf4, 0xee, 0xcd, 0x9d, 0xd2, 0xbb, 0xc5, 0xea, + 0xd1, 0x69, 0xe9, 0xa5, 0xc7, 0x4f, 0x72, 0xf6, 0x57, 0xab, 0x7f, 0x38, 0x0e, 0xb1, 0x32, 0x69, + 0x88, 0x08, 0x92, 0xfd, 0xeb, 0x85, 0x17, 0xc6, 0x86, 0x03, 0xbf, 0xf8, 0x27, 0xe5, 0x83, 0xc9, + 0xf1, 0xc6, 0x73, 0x1d, 0x52, 0xfc, 0x72, 0xe0, 0xab, 0x3e, 0xba, 0x7d, 0x41, 0xa9, 0x10, 0x50, + 0x90, 0x5b, 0xf9, 0x58, 0x80, 0x13, 0x5e, 0x37, 0xc6, 0xde, 0xf0, 0x01, 0xf3, 0xd0, 0x93, 0xbe, + 0x19, 0x4e, 0x8f, 0x73, 0x7a, 0x2a, 0xc0, 0xe9, 0xb1, 0x57, 0xa8, 0xde, 0x0a, 0x66, 0xc0, 0x55, + 0x59, 0x5a, 0xdf, 0x87, 0x32, 0xa7, 0xf8, 0x67, 0x01, 0x72, 0xbe, 0x97, 0x48, 0x6e, 0x04, 0xb3, + 0xe4, 0x09, 0x20, 0xdd, 0xda, 0x27, 0x00, 0xa7, 0xfb, 0x81, 0x00, 0xf3, 0xae, 0x77, 0x38, 0xaf, + 0xf8, 0x58, 0x70, 0x53, 0x92, 0xde, 0x0a, 0xa1, 0xc4, 0xa9, 0xfc, 0x5e, 0x00, 0x69, 0xcc, 0x0d, + 0xcc, 0x6b, 0x3e, 0xd8, 0xde, 0xaa, 0xd2, 0xcd, 0xd0, 0xaa, 0x9c, 0xdc, 0x2f, 0x04, 0x38, 0xee, + 0x7e, 0xb7, 0xe0, 0x6a, 0xe0, 0x31, 0xdb, 0xb4, 0xa4, 0xaf, 0x87, 0xd1, 0xe2, 0x6c, 0x7a, 0xf0, + 0x92, 0xf3, 0xe8, 0xd9, 0x6f, 0x11, 0x71, 0xc8, 0x4b, 0x6f, 0x4c, 0x26, 0x3f, 0xe4, 0x08, 0xf7, + 0x33, 0xe4, 0xab, 0x81, 0xbc, 0xec, 0xd0, 0xf2, 0x75, 0xc4, 0xf8, 0x43, 0x63, 0x23, 0x66, 0xc6, + 0x5c, 0xa6, 0xb8, 0x16, 0xc8, 0xcb, 0x6e, 0xaa, 0xbe, 0x31, 0x13, 0xe0, 0xea, 0x84, 0xb1, 0x14, + 0xf8, 0x5e, 0x87, 0xb8, 0x11, 0x3c, 0x36, 0x5d, 0x01, 0x7c, 0x97, 0x82, 0xc0, 0x17, 0x20, 0x9e, + 0x08, 0x70, 0x6a, 0xdc, 0xc9, 0xfa, 0xf5, 0x09, 0x3d, 0x62, 0x0f, 0xf7, 0xb5, 0xf0, 0xba, 0xc3, + 0x29, 0xe8, 0x7a, 0x8a, 0x7e, 0x35, 0x50, 0x2c, 0x3b, 0xb4, 0xfc, 0x53, 0x70, 0xdc, 0xb1, 0x38, + 0xf3, 0xd6, 0xb8, 0x63, 0xea, 0xeb, 0xc1, 0xe3, 0xda, 0xa9, 0xeb, 0xeb, 0xad, 0x20, 0xa7, 0xd3, + 0x3f, 0x15, 0x40, 0x74, 0x39, 0x76, 0xbe, 0xec, 0x03, 0x3d, 0xaa, 0x22, 0x5d, 0x9b, 0x58, 0x85, + 0x93, 0xf8, 0x31, 0x1c, 0x1d, 0x39, 0x00, 0xf6, 0xdb, 0x88, 0x38, 0x15, 0xa4, 0x37, 0x27, 0x54, + 0xe0, 0xd6, 0x1f, 0xc1, 0xcb, 0xa3, 0x07, 0xb1, 0xaf, 0xfb, 0xa0, 0x8d, 0x68, 0x48, 0x5f, 0x9b, + 0x54, 0x83, 0x13, 0xf8, 0x48, 0x80, 0x05, 0x8f, 0xe3, 0xd2, 0xaf, 0xfa, 0xfe, 0x80, 0xbb, 0xa9, + 0x49, 0xdf, 0x08, 0xa5, 0xd6, 0x27, 0xb4, 0xd6, 0xfc, 0xe4, 0xd9, 0xa2, 0xf0, 0xe9, 0xb3, 0x45, + 0xe1, 0x5f, 0xcf, 0x16, 0x85, 0x5f, 0x3f, 0x5f, 0x9c, 0xfa, 0xf4, 0xf9, 0xe2, 0xd4, 0x3f, 0x9f, + 0x2f, 0x4e, 0xbd, 0x77, 0xc7, 0x56, 0x08, 0x95, 0xfa, 0x26, 0xb6, 0xd0, 0x2e, 0x29, 0x70, 0x83, + 0x97, 0x64, 0x4d, 0xc7, 0xf6, 0xc7, 0x26, 0x52, 0xd4, 0x42, 0x5b, 0xab, 0x77, 0x5b, 0x98, 0x0c, + 0xfe, 0x6b, 0x0e, 0x2b, 0x9a, 0x76, 0x13, 0xec, 0x3f, 0xdc, 0x5c, 0xf9, 0x5f, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x65, 0x6f, 0x64, 0x66, 0x3b, 0x34, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -3294,6 +3346,13 @@ func (m *MsgCreateSpotLimitOrderResponse) MarshalToSizedBuffer(dAtA []byte) (int _ = i var l int _ = l + if len(m.OrderHash) > 0 { + i -= len(m.OrderHash) + copy(dAtA[i:], m.OrderHash) + i = encodeVarintTx(dAtA, i, uint64(len(m.OrderHash))) + i-- + dAtA[i] = 0xa + } return len(dAtA) - i, nil } @@ -3361,6 +3420,15 @@ func (m *MsgBatchCreateSpotLimitOrdersResponse) MarshalToSizedBuffer(dAtA []byte _ = i var l int _ = l + if len(m.OrderHashes) > 0 { + for iNdEx := len(m.OrderHashes) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.OrderHashes[iNdEx]) + copy(dAtA[i:], m.OrderHashes[iNdEx]) + i = encodeVarintTx(dAtA, i, uint64(len(m.OrderHashes[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } return len(dAtA) - i, nil } @@ -3888,6 +3956,13 @@ func (m *MsgCreateDerivativeLimitOrderResponse) MarshalToSizedBuffer(dAtA []byte _ = i var l int _ = l + if len(m.OrderHash) > 0 { + i -= len(m.OrderHash) + copy(dAtA[i:], m.OrderHash) + i = encodeVarintTx(dAtA, i, uint64(len(m.OrderHash))) + i-- + dAtA[i] = 0xa + } return len(dAtA) - i, nil } @@ -3955,6 +4030,15 @@ func (m *MsgBatchCreateDerivativeLimitOrdersResponse) MarshalToSizedBuffer(dAtA _ = i var l int _ = l + if len(m.OrderHashes) > 0 { + for iNdEx := len(m.OrderHashes) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.OrderHashes[iNdEx]) + copy(dAtA[i:], m.OrderHashes[iNdEx]) + i = encodeVarintTx(dAtA, i, uint64(len(m.OrderHashes[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } return len(dAtA) - i, nil } @@ -4096,6 +4180,19 @@ func (m *MsgBatchCancelSpotOrdersResponse) MarshalToSizedBuffer(dAtA []byte) (in _ = i var l int _ = l + if len(m.Success) > 0 { + for iNdEx := len(m.Success) - 1; iNdEx >= 0; iNdEx-- { + i-- + if m.Success[iNdEx] { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + } + i = encodeVarintTx(dAtA, i, uint64(len(m.Success))) + i-- + dAtA[i] = 0xa + } return len(dAtA) - i, nil } @@ -4344,6 +4441,19 @@ func (m *MsgBatchCancelDerivativeOrdersResponse) MarshalToSizedBuffer(dAtA []byt _ = i var l int _ = l + if len(m.Success) > 0 { + for iNdEx := len(m.Success) - 1; iNdEx >= 0; iNdEx-- { + i-- + if m.Success[iNdEx] { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + } + i = encodeVarintTx(dAtA, i, uint64(len(m.Success))) + i-- + dAtA[i] = 0xa + } return len(dAtA) - i, nil } @@ -5369,6 +5479,55 @@ func (m *DerivativeMarketBandOraclePromotionProposal) MarshalToSizedBuffer(dAtA return len(dAtA) - i, nil } +func (m *LiquidityMiningCampaignProposal) 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 *LiquidityMiningCampaignProposal) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LiquidityMiningCampaignProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Campaign != nil { + { + size, err := m.Campaign.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = encodeVarintTx(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x12 + } + if len(m.Title) > 0 { + i -= len(m.Title) + copy(dAtA[i:], m.Title) + i = encodeVarintTx(dAtA, i, uint64(len(m.Title))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func encodeVarintTx(dAtA []byte, offset int, v uint64) int { offset -= sovTx(v) base := offset @@ -5457,6 +5616,10 @@ func (m *MsgCreateSpotLimitOrderResponse) Size() (n int) { } var l int _ = l + l = len(m.OrderHash) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } return n } @@ -5485,6 +5648,12 @@ func (m *MsgBatchCreateSpotLimitOrdersResponse) Size() (n int) { } var l int _ = l + if len(m.OrderHashes) > 0 { + for _, s := range m.OrderHashes { + l = len(s) + n += 1 + l + sovTx(uint64(l)) + } + } return n } @@ -5686,6 +5855,10 @@ func (m *MsgCreateDerivativeLimitOrderResponse) Size() (n int) { } var l int _ = l + l = len(m.OrderHash) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } return n } @@ -5714,6 +5887,12 @@ func (m *MsgBatchCreateDerivativeLimitOrdersResponse) Size() (n int) { } var l int _ = l + if len(m.OrderHashes) > 0 { + for _, s := range m.OrderHashes { + l = len(s) + n += 1 + l + sovTx(uint64(l)) + } + } return n } @@ -5776,6 +5955,9 @@ func (m *MsgBatchCancelSpotOrdersResponse) Size() (n int) { } var l int _ = l + if len(m.Success) > 0 { + n += 1 + sovTx(uint64(len(m.Success))) + len(m.Success)*1 + } return n } @@ -5883,6 +6065,9 @@ func (m *MsgBatchCancelDerivativeOrdersResponse) Size() (n int) { } var l int _ = l + if len(m.Success) > 0 { + n += 1 + sovTx(uint64(len(m.Success))) + len(m.Success)*1 + } return n } @@ -6303,6 +6488,27 @@ func (m *DerivativeMarketBandOraclePromotionProposal) Size() (n int) { return n } +func (m *LiquidityMiningCampaignProposal) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Title) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.Campaign != nil { + l = m.Campaign.Size() + n += 1 + l + sovTx(uint64(l)) + } + return n +} + func sovTx(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -6847,6 +7053,38 @@ func (m *MsgCreateSpotLimitOrderResponse) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: MsgCreateSpotLimitOrderResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OrderHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OrderHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -7013,6 +7251,38 @@ func (m *MsgBatchCreateSpotLimitOrdersResponse) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: MsgBatchCreateSpotLimitOrdersResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OrderHashes", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OrderHashes = append(m.OrderHashes, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -8662,6 +8932,38 @@ func (m *MsgCreateDerivativeLimitOrderResponse) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: MsgCreateDerivativeLimitOrderResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OrderHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OrderHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -8828,6 +9130,38 @@ func (m *MsgBatchCreateDerivativeLimitOrdersResponse) Unmarshal(dAtA []byte) err return fmt.Errorf("proto: MsgBatchCreateDerivativeLimitOrdersResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OrderHashes", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OrderHashes = append(m.OrderHashes, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -9222,6 +9556,76 @@ func (m *MsgBatchCancelSpotOrdersResponse) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: MsgBatchCancelSpotOrdersResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Success = append(m.Success, bool(v != 0)) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + elementCount = packedLen + if elementCount != 0 && len(m.Success) == 0 { + m.Success = make([]bool, 0, elementCount) + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Success = append(m.Success, bool(v != 0)) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType) + } default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -9927,6 +10331,76 @@ func (m *MsgBatchCancelDerivativeOrdersResponse) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: MsgBatchCancelDerivativeOrdersResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Success = append(m.Success, bool(v != 0)) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + elementCount = packedLen + if elementCount != 0 && len(m.Success) == 0 { + m.Success = make([]bool, 0, elementCount) + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Success = append(m.Success, bool(v != 0)) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType) + } default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -13278,6 +13752,156 @@ func (m *DerivativeMarketBandOraclePromotionProposal) Unmarshal(dAtA []byte) err } return nil } +func (m *LiquidityMiningCampaignProposal) 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 ErrIntOverflowTx + } + 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: LiquidityMiningCampaignProposal: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LiquidityMiningCampaignProposal: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Title = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Campaign", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Campaign == nil { + m.Campaign = &LiquidityMiningCampaign{} + } + if err := m.Campaign.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipTx(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0