diff --git a/local_node.sh b/local_node.sh index d54df861..2d4ffa9e 100755 --- a/local_node.sh +++ b/local_node.sh @@ -21,6 +21,7 @@ MAX_GAS=10000000000 BTC_VAULT=() # ("
" "" "") RUNES_VAULT=() TRUSTED_NON_BTC_RELAYER="" +TRUSTED_ORACLE="" PROTOCOL_FEE_COLLECTOR="" # Remember to change to other types of keyring like 'file' in-case exposing to outside world, @@ -107,7 +108,12 @@ if [[ $overwrite == "y" || $overwrite == "Y" ]]; then # set trusted non btc relayer if [ -n "$TRUSTED_NON_BTC_RELAYER" ]; then - jq --arg relayer "$TRUSTED_NON_BTC_RELAYER" '.app_state["btcbridge"]["params"]["non_btc_relayers"][0]=$relayer' "$GENESIS" >"$TMP_GENESIS" && mv "$TMP_GENESIS" "$GENESIS" + jq --arg relayer "$TRUSTED_NON_BTC_RELAYER" '.app_state["btcbridge"]["params"]["trusted_non_btc_relayers"][0]=$relayer' "$GENESIS" >"$TMP_GENESIS" && mv "$TMP_GENESIS" "$GENESIS" + fi + + # set trusted oracle + if [ -n "$TRUSTED_ORACLE" ]; then + jq --arg oracle "$TRUSTED_ORACLE" '.app_state["btcbridge"]["params"]["trusted_oracles"][0]=$oracle' "$GENESIS" >"$TMP_GENESIS" && mv "$TMP_GENESIS" "$GENESIS" fi # set protocol fee collector diff --git a/local_node_dev.sh b/local_node_dev.sh index f8c9083f..07acd7a7 100755 --- a/local_node_dev.sh +++ b/local_node_dev.sh @@ -21,6 +21,7 @@ MAX_GAS=10000000000 BTC_VAULT=() # ("
" "" "") RUNES_VAULT=() TRUSTED_NON_BTC_RELAYER="" +TRUSTED_ORACLE="" PROTOCOL_FEE_COLLECTOR="" # gov params @@ -115,7 +116,12 @@ if [[ $overwrite == "y" || $overwrite == "Y" ]]; then # set trusted non btc relayer if [ -n "$TRUSTED_NON_BTC_RELAYER" ]; then - jq --arg relayer "$TRUSTED_NON_BTC_RELAYER" '.app_state["btcbridge"]["params"]["non_btc_relayers"][0]=$relayer' "$GENESIS" >"$TMP_GENESIS" && mv "$TMP_GENESIS" "$GENESIS" + jq --arg relayer "$TRUSTED_NON_BTC_RELAYER" '.app_state["btcbridge"]["params"]["trusted_non_btc_relayers"][0]=$relayer' "$GENESIS" >"$TMP_GENESIS" && mv "$TMP_GENESIS" "$GENESIS" + fi + + # set trusted oracle + if [ -n "$TRUSTED_ORACLE" ]; then + jq --arg oracle "$TRUSTED_ORACLE" '.app_state["btcbridge"]["params"]["trusted_oracles"][0]=$oracle' "$GENESIS" >"$TMP_GENESIS" && mv "$TMP_GENESIS" "$GENESIS" fi # set protocol fee collector diff --git a/proto/side/btcbridge/btcbridge.proto b/proto/side/btcbridge/btcbridge.proto index ac6e2909..f09a373f 100644 --- a/proto/side/btcbridge/btcbridge.proto +++ b/proto/side/btcbridge/btcbridge.proto @@ -46,6 +46,14 @@ message SigningRequest { SigningStatus status = 5; } +// Withdrawal Request +message WithdrawRequest { + string address = 1; + string amount = 2; + uint64 sequence = 3; + string txid = 4; +} + // Bitcoin UTXO message UTXO { string txid = 1; diff --git a/proto/side/btcbridge/params.proto b/proto/side/btcbridge/params.proto index 2631e348..f9f3bc0b 100644 --- a/proto/side/btcbridge/params.proto +++ b/proto/side/btcbridge/params.proto @@ -20,15 +20,19 @@ message Params { // Indicates if withdrawal is enabled bool withdraw_enabled = 5; // Trusted relayers for non-btc asset deposit - repeated string non_btc_relayers = 6; + repeated string trusted_non_btc_relayers = 6; + // Trusted oracles for providing offchain data, e.g. bitcoin fee rate + repeated string trusted_oracles = 7; // Asset vaults - repeated Vault vaults = 7; + repeated Vault vaults = 8; + // Withdrawal params + WithdrawParams withdraw_params = 9 [(gogoproto.nullable) = false]; // Protocol limitations - ProtocolLimits protocol_limits = 8 [(gogoproto.nullable) = false]; + ProtocolLimits protocol_limits = 10 [(gogoproto.nullable) = false]; // Protocol fees - ProtocolFees protocol_fees = 9 [(gogoproto.nullable) = false]; + ProtocolFees protocol_fees = 11 [(gogoproto.nullable) = false]; // TSS params - TSSParams tss_params = 10 [(gogoproto.nullable) = false]; + TSSParams tss_params = 12 [(gogoproto.nullable) = false]; } // AssetType defines the type of asset @@ -55,6 +59,15 @@ message Vault { uint64 version = 4; } +message WithdrawParams { + // Maximum number of utxos used to build the signing request; O means unlimited + uint32 max_utxo_num = 1; + // Period for handling btc withdrawal requests + int64 btc_batch_withdraw_period = 2; + // Maximum number of btc withdrawal requests to be handled per batch + uint32 max_btc_batch_withdraw_num = 3; +} + // ProtocolLimits defines the params related to the the protocol limitations message ProtocolLimits { // The minimum deposit amount for btc in sat diff --git a/proto/side/btcbridge/query.proto b/proto/side/btcbridge/query.proto index 48954c34..8c449558 100644 --- a/proto/side/btcbridge/query.proto +++ b/proto/side/btcbridge/query.proto @@ -27,6 +27,10 @@ service Query { rpc QueryBlockHeaderByHash(QueryBlockHeaderByHashRequest) returns (QueryBlockHeaderByHashResponse) { option (google.api.http).get = "/side/btcbridge/hash/{hash}"; } + // QueryFeeRate queries the current bitcoin network fee rate on the side chain. + rpc QueryFeeRate(QueryFeeRateRequest) returns (QueryFeeRateResponse) { + option (google.api.http).get = "/side/btcbridge/feerate"; + } // QuerySigningRequests queries the signing requests by the given status. rpc QuerySigningRequests(QuerySigningRequestsRequest) returns (QuerySigningRequestsResponse) { option (google.api.http).get = "/side/btcbridge/signing/requests"; @@ -39,10 +43,6 @@ service Query { rpc QuerySigningRequestByTxHash(QuerySigningRequestByTxHashRequest) returns (QuerySigningRequestByTxHashResponse) { option (google.api.http).get = "/side/btcbridge/signing/requests/tx/{txid}"; } - // QueryWithdrawNetworkFee queries the bitcoin network fee for withdrawal. - rpc QueryWithdrawNetworkFee(QueryWithdrawNetworkFeeRequest) returns (QueryWithdrawNetworkFeeResponse) { - option (google.api.http).get = "/side/btcbridge/withdrawal/fee"; - } // QueryUTXOs queries all utxos. rpc QueryUTXOs(QueryUTXOsRequest) returns (QueryUTXOsResponse) { option (google.api.http).get = "/side/btcbridge/utxos"; @@ -107,16 +107,12 @@ message QuerySigningRequestByTxHashResponse { SigningRequest request = 1; } -// QueryWithdrawNetworkFeeRequest is request type for the Query/WithdrawNetworkFee RPC method. -message QueryWithdrawNetworkFeeRequest { - string sender = 1; - string amount = 2; - string fee_rate = 3; -} +// QueryFeeRateRequest is request type for the Query/FeeRate RPC method. +message QueryFeeRateRequest {} -// QueryWithdrawNetworkFeeResponse is response type for the Query/WithdrawNetworkFee RPC method. -message QueryWithdrawNetworkFeeResponse { - int64 fee = 1; +// QueryFeeRateResponse is response type for the Query/FeeRate RPC method. +message QueryFeeRateResponse { + int64 fee_rate = 1; } // QueryParamsRequest is request type for the Query/Params RPC method. diff --git a/proto/side/btcbridge/tx.proto b/proto/side/btcbridge/tx.proto index 5938b2ff..e6ab88a7 100644 --- a/proto/side/btcbridge/tx.proto +++ b/proto/side/btcbridge/tx.proto @@ -12,12 +12,16 @@ option go_package = "github.com/sideprotocol/side/x/btcbridge/types"; service Msg { // SubmitBlockHeaders submits bitcoin block headers to the side chain. rpc SubmitBlockHeaders (MsgSubmitBlockHeaders) returns (MsgSubmitBlockHeadersResponse); - // UpdateNonBtcRelayers updates the trusted non-btc asset relayers. - rpc UpdateNonBtcRelayers (MsgUpdateNonBtcRelayers) returns (MsgUpdateNonBtcRelayersResponse); - // SubmitDepositTransaction submits bitcoin transaction to the side chain. + // SubmitDepositTransaction submits the bitcoin deposit transaction to the side chain. rpc SubmitDepositTransaction (MsgSubmitDepositTransaction) returns (MsgSubmitDepositTransactionResponse); - // SubmitWithdrawalTransaction submits bitcoin transaction to the side chain. + // SubmitWithdrawalTransaction submits the bitcoin withdrawal transaction to the side chain. rpc SubmitWithdrawTransaction (MsgSubmitWithdrawTransaction) returns (MsgSubmitWithdrawTransactionResponse); + // SubmitFeeRate submits the bitcoin network fee rate to the side chain. + rpc SubmitFeeRate (MsgSubmitFeeRate) returns (MsgSubmitFeeRateResponse); + // UpdateTrustedNonBtcRelayers updates the trusted non-btc asset relayers. + rpc UpdateTrustedNonBtcRelayers (MsgUpdateTrustedNonBtcRelayers) returns (MsgUpdateTrustedNonBtcRelayersResponse); + // UpdateTrustedOracles updates the trusted oracles. + rpc UpdateTrustedOracles (MsgUpdateTrustedOracles) returns (MsgUpdateTrustedOraclesResponse); // WithdrawToBitcoin withdraws the asset to bitcoin. rpc WithdrawToBitcoin (MsgWithdrawToBitcoin) returns (MsgWithdrawToBitcoinResponse); // SubmitSignatures submits the signatures of the signing request to the side chain. @@ -47,16 +51,6 @@ message MsgSubmitBlockHeaders { message MsgSubmitBlockHeadersResponse { } -// MsgUpdateNonBtcRelayers defines the Msg/UpdateNonBtcRelayers request type. -message MsgUpdateNonBtcRelayers { - string sender = 1; - repeated string relayers = 2; -} - -// MsgUpdateNonBtcRelayersResponse defines the Msg/UpdateNonBtcRelayers response type. -message MsgUpdateNonBtcRelayersResponse { -} - // MsgSubmitDepositTransaction defines the Msg/SubmitDepositTransaction request type. message MsgSubmitDepositTransaction { // this is the relayer address who submits the bitcoin transaction to the side chain @@ -88,13 +82,41 @@ message MsgSubmitWithdrawTransaction { message MsgSubmitWithdrawTransactionResponse { } +// MsgSubmitFeeRate defines the Msg/SubmitFeeRate request type. +message MsgSubmitFeeRate { + string sender = 1; + int64 fee_rate = 2; +} + +// MsgSubmitFeeRateResponse defines the Msg/SubmitFeeRate response type. +message MsgSubmitFeeRateResponse { +} + +// MsgUpdateTrustedNonBtcRelayers defines the Msg/UpdateTrustedNonBtcRelayers request type. +message MsgUpdateTrustedNonBtcRelayers { + string sender = 1; + repeated string relayers = 2; +} + +// MsgUpdateTrustedNonBtcRelayersResponse defines the Msg/UpdateTrustedNonBtcRelayers response type. +message MsgUpdateTrustedNonBtcRelayersResponse { +} + +// MsgUpdateTrustedOracles defines the Msg/UpdateTrustedOracles request type. +message MsgUpdateTrustedOracles { + string sender = 1; + repeated string oracles = 2; +} + +// MsgUpdateTrustedOraclesResponse defines the Msg/UpdateTrustedOracles response type. +message MsgUpdateTrustedOraclesResponse { +} + // MsgWithdrawToBitcoin defines the Msg/WithdrawToBitcoin request type. message MsgWithdrawToBitcoin { string sender = 1; // withdraw amount in satoshi, etc: 100000000sat = 1btc string amount = 2; - // fee rate in sats/vB - string fee_rate = 3; } // MsgWithdrawToBitcoinResponse defines the Msg/WithdrawToBitcoin response type. diff --git a/x/btcbridge/abci.go b/x/btcbridge/abci.go index 3223d418..a34264b0 100644 --- a/x/btcbridge/abci.go +++ b/x/btcbridge/abci.go @@ -7,12 +7,59 @@ import ( "github.com/sideprotocol/side/x/btcbridge/types" ) -// EndBlocker called at every block to handle DKG requests +// EndBlocker called at every block func EndBlocker(ctx sdk.Context, k keeper.Keeper) { + handleBtcWithdrawRequests(ctx, k) handleDKGRequests(ctx, k) handleVaultTransfer(ctx, k) } +// handleBtcWithdrawRequests performs the batch btc withdrawal request handling +func handleBtcWithdrawRequests(ctx sdk.Context, k keeper.Keeper) { + p := k.GetParams(ctx) + + // check block height + if ctx.BlockHeight()%p.WithdrawParams.BtcBatchWithdrawPeriod != 0 { + return + } + + // get the pending btc withdrawal request + pendingWithdrawRequests := k.GetPendingBtcWithdrawRequests(ctx, p.WithdrawParams.MaxBtcBatchWithdrawNum) + if len(pendingWithdrawRequests) == 0 { + return + } + + feeRate := k.GetFeeRate(ctx) + if feeRate == 0 { + k.Logger(ctx).Error("invalid fee rate", feeRate) + return + } + + vault := types.SelectVaultByAssetType(p.Vaults, types.AssetType_ASSET_TYPE_BTC) + if vault == nil { + k.Logger(ctx).Error("btc vault does not exist") + return + } + + signingRequest, err := k.BuildBtcBatchWithdrawSigningRequest(ctx, pendingWithdrawRequests, feeRate, vault.Address) + if err != nil { + k.Logger(ctx).Error("failed to build signing request", "err", err) + return + } + + for _, req := range pendingWithdrawRequests { + // update withdrawal request + req.Txid = signingRequest.Txid + k.SetWithdrawRequest(ctx, req) + + // remove from the pending queue + k.RemoveFromBtcWithdrawRequestQueue(ctx, req) + + // emit event + k.EmitEvent(ctx, req.Address, sdk.NewAttribute("txid", req.Txid)) + } +} + // handleDKGRequests performs the DKG request handling func handleDKGRequests(ctx sdk.Context, k keeper.Keeper) { pendingDKGRequests := k.GetPendingDKGRequests(ctx) @@ -72,6 +119,7 @@ func handleVaultTransfer(ctx sdk.Context, k keeper.Keeper) { if !k.VaultTransferCompleted(ctx, sourceRunesVault) { if err := k.TransferVault(ctx, sourceVersion, destVersion, types.AssetType_ASSET_TYPE_RUNES, nil, req.TargetUtxoNum, req.FeeRate); err != nil { k.Logger(ctx).Error("transfer vault errored", "source version", sourceVersion, "destination version", destVersion, "asset type", types.AssetType_ASSET_TYPE_RUNES, "target utxo num", req.TargetUtxoNum, "fee rate", req.FeeRate, "err", err) + continue } } @@ -79,6 +127,7 @@ func handleVaultTransfer(ctx sdk.Context, k keeper.Keeper) { if k.VaultTransferCompleted(ctx, sourceRunesVault) && !k.VaultTransferCompleted(ctx, sourceBtcVault) { if err := k.TransferVault(ctx, sourceVersion, destVersion, types.AssetType_ASSET_TYPE_BTC, nil, req.TargetUtxoNum, req.FeeRate); err != nil { k.Logger(ctx).Error("transfer vault errored", "source version", sourceVersion, "destination version", destVersion, "asset type", types.AssetType_ASSET_TYPE_BTC, "target utxo num", req.TargetUtxoNum, "fee rate", req.FeeRate, "err", err) + continue } } diff --git a/x/btcbridge/client/cli/query.go b/x/btcbridge/client/cli/query.go index efe180c4..c504a75f 100644 --- a/x/btcbridge/client/cli/query.go +++ b/x/btcbridge/client/cli/query.go @@ -133,6 +133,34 @@ func CmdQueryBlock() *cobra.Command { return cmd } +// CmdQueryFeeRate returns the command to query the bitcoin network fee rate +func CmdQueryFeeRate() *cobra.Command { + cmd := &cobra.Command{ + Use: "fee-rate", + Short: "Query the current bitcoin network fee rate on the side chain", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + + queryClient := types.NewQueryClient(clientCtx) + + res, err := queryClient.QueryFeeRate(cmd.Context(), &types.QueryFeeRateRequest{}) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} + // CmdQuerySigningRequests returns the command to query signing requests func CmdQuerySigningRequests() *cobra.Command { cmd := &cobra.Command{ diff --git a/x/btcbridge/client/cli/tx.go b/x/btcbridge/client/cli/tx.go index f415e408..7ceaf805 100644 --- a/x/btcbridge/client/cli/tx.go +++ b/x/btcbridge/client/cli/tx.go @@ -39,7 +39,9 @@ func GetTxCmd() *cobra.Command { } cmd.AddCommand(CmdSubmitBlocks()) - cmd.AddCommand(CmdUpdateNonBtcRelayers()) + cmd.AddCommand(CmdSubmitFeeRate()) + cmd.AddCommand(CmdUpdateTrustedNonBtcRelayers()) + cmd.AddCommand(CmdUpdateTrustedOracles()) cmd.AddCommand(CmdWithdrawToBitcoin()) cmd.AddCommand(CmdSubmitSignatures()) cmd.AddCommand(CmdCompleteDKG()) @@ -80,10 +82,10 @@ func CmdSubmitBlocks() *cobra.Command { return cmd } -func CmdUpdateNonBtcRelayers() *cobra.Command { +func CmdSubmitFeeRate() *cobra.Command { cmd := &cobra.Command{ - Use: "update-non-btc-relayers [relayers]", - Short: "Update non-btc asset relayers", + Use: "submit-fee-rate [fee rate]", + Short: "Submit the latest fee rate of the bitcoin network", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) (err error) { clientCtx, err := client.GetClientTxContext(cmd) @@ -91,7 +93,70 @@ func CmdUpdateNonBtcRelayers() *cobra.Command { return err } - msg := types.NewMsgUpdateNonBtcRelayers( + feeRate, err := strconv.ParseInt(args[0], 10, 64) + if err != nil { + return err + } + + msg := types.NewMsgSubmitFeeRate( + clientCtx.GetFromAddress().String(), + feeRate, + ) + + if err := msg.ValidateBasic(); err != nil { + return err + } + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + + return cmd +} + +func CmdUpdateTrustedNonBtcRelayers() *cobra.Command { + cmd := &cobra.Command{ + Use: "update-trusted-relayers [relayers]", + Short: "Update trusted non-btc asset relayers", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) (err error) { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + msg := types.NewMsgUpdateTrustedNonBtcRelayers( + clientCtx.GetFromAddress().String(), + strings.Split(args[0], listSeparator), + ) + + if err := msg.ValidateBasic(); err != nil { + return err + } + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + + return cmd +} + +func CmdUpdateTrustedOracles() *cobra.Command { + cmd := &cobra.Command{ + Use: "update-trusted-oracles [oracles]", + Short: "Update trusted oracles", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) (err error) { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + msg := types.NewMsgUpdateTrustedOracles( clientCtx.GetFromAddress().String(), strings.Split(args[0], listSeparator), ) @@ -112,9 +177,9 @@ func CmdUpdateNonBtcRelayers() *cobra.Command { // Withdraw To Bitcoin func CmdWithdrawToBitcoin() *cobra.Command { cmd := &cobra.Command{ - Use: "withdraw [amount] [fee-rate]", + Use: "withdraw [amount]", Short: "Withdraw bitcoin asset to the given sender", - Args: cobra.ExactArgs(2), + Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) (err error) { clientCtx, err := client.GetClientTxContext(cmd) if err != nil { @@ -129,7 +194,6 @@ func CmdWithdrawToBitcoin() *cobra.Command { msg := types.NewMsgWithdrawToBitcoin( clientCtx.GetFromAddress().String(), args[0], - args[1], ) if err := msg.ValidateBasic(); err != nil { diff --git a/x/btcbridge/keeper/consolidate.go b/x/btcbridge/keeper/consolidate.go index 1cbd2214..20d66d00 100644 --- a/x/btcbridge/keeper/consolidate.go +++ b/x/btcbridge/keeper/consolidate.go @@ -37,6 +37,10 @@ func (k Keeper) handleBtcConsolidation(ctx sdk.Context, vaultVersion uint64, tar return types.ErrInsufficientUTXOs } + if err := k.checkUtxos(ctx, targetUTXOs); err != nil { + return err + } + p, recipientUTXO, err := types.BuildTransferAllBtcPsbt(targetUTXOs, vault.Address, feeRate) if err != nil { return err @@ -57,7 +61,7 @@ func (k Keeper) handleBtcConsolidation(ctx sdk.Context, vaultVersion uint64, tar // set signing request signingReq := &types.SigningRequest{ Address: k.authority, - Sequence: k.IncrementRequestSequence(ctx), + Sequence: k.IncrementSigningRequestSequence(ctx), Txid: p.UnsignedTx.TxHash().String(), Psbt: psbtB64, Status: types.SigningStatus_SIGNING_STATUS_PENDING, @@ -97,6 +101,10 @@ func (k Keeper) handleRunesConsolidation(ctx sdk.Context, vaultVersion uint64, r return err } + if err := k.checkUtxos(ctx, targetRunesUTXOs, selectedUtxos); err != nil { + return err + } + psbtB64, err := p.B64Encode() if err != nil { return types.ErrFailToSerializePsbt @@ -120,11 +128,12 @@ func (k Keeper) handleRunesConsolidation(ctx sdk.Context, vaultVersion uint64, r // set signing request signingReq := &types.SigningRequest{ Address: k.authority, - Sequence: k.IncrementRequestSequence(ctx), + Sequence: k.IncrementSigningRequestSequence(ctx), Txid: p.UnsignedTx.TxHash().String(), Psbt: psbtB64, Status: types.SigningStatus_SIGNING_STATUS_PENDING, } + k.SetSigningRequest(ctx, signingReq) // Emit events k.EmitEvent(ctx, k.authority, diff --git a/x/btcbridge/keeper/msg_server.go b/x/btcbridge/keeper/msg_server.go index b6bf690c..af6df094 100644 --- a/x/btcbridge/keeper/msg_server.go +++ b/x/btcbridge/keeper/msg_server.go @@ -4,7 +4,6 @@ import ( "bytes" "context" "fmt" - "strconv" "github.com/btcsuite/btcd/btcutil/psbt" @@ -36,8 +35,8 @@ func (m msgServer) SubmitBlockHeaders(goCtx context.Context, msg *types.MsgSubmi return &types.MsgSubmitBlockHeadersResponse{}, nil } -// UpdateNonBtcRelayers implements types.MsgServer. -func (m msgServer) UpdateNonBtcRelayers(goCtx context.Context, msg *types.MsgUpdateNonBtcRelayers) (*types.MsgUpdateNonBtcRelayersResponse, error) { +// UpdateTrustedNonBtcRelayers implements types.MsgServer. +func (m msgServer) UpdateTrustedNonBtcRelayers(goCtx context.Context, msg *types.MsgUpdateTrustedNonBtcRelayers) (*types.MsgUpdateTrustedNonBtcRelayersResponse, error) { ctx := sdk.UnwrapSDKContext(goCtx) if err := msg.ValidateBasic(); err != nil { @@ -50,10 +49,30 @@ func (m msgServer) UpdateNonBtcRelayers(goCtx context.Context, msg *types.MsgUpd // update non-btc relayers params := m.GetParams(ctx) - params.NonBtcRelayers = msg.Relayers + params.TrustedNonBtcRelayers = msg.Relayers m.SetParams(ctx, params) - return &types.MsgUpdateNonBtcRelayersResponse{}, nil + return &types.MsgUpdateTrustedNonBtcRelayersResponse{}, nil +} + +// UpdateTrustedOracles implements types.MsgServer. +func (m msgServer) UpdateTrustedOracles(goCtx context.Context, msg *types.MsgUpdateTrustedOracles) (*types.MsgUpdateTrustedOraclesResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + if err := msg.ValidateBasic(); err != nil { + return nil, err + } + + if !m.IsTrustedOracle(ctx, msg.Sender) { + return nil, types.ErruntrustedOracle + } + + // update oracles + params := m.GetParams(ctx) + params.TrustedOracles = msg.Oracles + m.SetParams(ctx, params) + + return &types.MsgUpdateTrustedOraclesResponse{}, nil } // SubmitDepositTransaction implements types.MsgServer. @@ -114,6 +133,28 @@ func (m msgServer) SubmitWithdrawTransaction(goCtx context.Context, msg *types.M return &types.MsgSubmitWithdrawTransactionResponse{}, nil } +// SubmitFeeRate submits the bitcoin network fee rate +func (m msgServer) SubmitFeeRate(goCtx context.Context, msg *types.MsgSubmitFeeRate) (*types.MsgSubmitFeeRateResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + if err := msg.ValidateBasic(); err != nil { + return nil, err + } + + if !m.IsTrustedOracle(ctx, msg.Sender) { + return nil, types.ErruntrustedOracle + } + + m.SetFeeRate(ctx, msg.FeeRate) + + // Emit Events + m.EmitEvent(ctx, msg.Sender, + sdk.NewAttribute("fee_rate", fmt.Sprintf("%d", msg.FeeRate)), + ) + + return &types.MsgSubmitFeeRateResponse{}, nil +} + // WithdrawToBitcoin withdraws the asset to the bitcoin chain. func (m msgServer) WithdrawToBitcoin(goCtx context.Context, msg *types.MsgWithdrawToBitcoin) (*types.MsgWithdrawToBitcoinResponse, error) { if err := msg.ValidateBasic(); err != nil { @@ -141,22 +182,15 @@ func (m msgServer) WithdrawToBitcoin(goCtx context.Context, msg *types.MsgWithdr } } - feeRate, _ := strconv.ParseInt(msg.FeeRate, 10, 64) - - req, err := m.Keeper.NewSigningRequest(ctx, msg.Sender, amount, feeRate) + withdrawRequest, err := m.HandleWithdrawal(ctx, msg.Sender, amount) if err != nil { return nil, err } - // lock assets - if err := m.LockAssets(ctx, req, amount); err != nil { - return nil, err - } - // Emit events m.EmitEvent(ctx, msg.Sender, - sdk.NewAttribute("amount", msg.Amount), - sdk.NewAttribute("txid", req.Txid), + sdk.NewAttribute("amount", amount.String()), + sdk.NewAttribute("txid", withdrawRequest.Txid), ) return &types.MsgWithdrawToBitcoinResponse{}, nil diff --git a/x/btcbridge/keeper/oracle.go b/x/btcbridge/keeper/oracle.go new file mode 100644 index 00000000..d8185c36 --- /dev/null +++ b/x/btcbridge/keeper/oracle.go @@ -0,0 +1,23 @@ +package keeper + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/sideprotocol/side/x/btcbridge/types" +) + +// SetFeeRate sets the bitcoin network fee rate +func (k Keeper) SetFeeRate(ctx sdk.Context, feeRate int64) { + store := ctx.KVStore(k.storeKey) + + store.Set(types.BtcFeeRateKey, sdk.Uint64ToBigEndian(uint64(feeRate))) +} + +// GetFeeRate gets the bitcoin network fee rate +func (k Keeper) GetFeeRate(ctx sdk.Context) int64 { + store := ctx.KVStore(k.storeKey) + + bz := store.Get(types.BtcFeeRateKey) + + return int64(sdk.BigEndianToUint64(bz)) +} diff --git a/x/btcbridge/keeper/params.go b/x/btcbridge/keeper/params.go index 070510c1..95d9e474 100644 --- a/x/btcbridge/keeper/params.go +++ b/x/btcbridge/keeper/params.go @@ -26,9 +26,14 @@ func (k Keeper) ProtocolWithdrawFeeEnabled(ctx sdk.Context) bool { return k.GetParams(ctx).ProtocolFees.WithdrawFee > 0 } +// ProtocolFeeCollector gets the protocol fee collector +func (k Keeper) ProtocolFeeCollector(ctx sdk.Context) string { + return k.GetParams(ctx).ProtocolFees.Collector +} + // IsTrustedNonBtcRelayer returns true if the given address is a trusted non-btc relayer, false otherwise func (k Keeper) IsTrustedNonBtcRelayer(ctx sdk.Context, addr string) bool { - for _, relayer := range k.GetParams(ctx).NonBtcRelayers { + for _, relayer := range k.GetParams(ctx).TrustedNonBtcRelayers { if relayer == addr { return true } @@ -37,6 +42,17 @@ func (k Keeper) IsTrustedNonBtcRelayer(ctx sdk.Context, addr string) bool { return false } +// IsTrustedOracle returns true if the given address is a trusted oracle, false otherwise +func (k Keeper) IsTrustedOracle(ctx sdk.Context, addr string) bool { + for _, oracle := range k.GetParams(ctx).TrustedOracles { + if oracle == addr { + return true + } + } + + return false +} + // GetVaultByAssetTypeAndVersion gets the vault by the given asset type and version func (k Keeper) GetVaultByAssetTypeAndVersion(ctx sdk.Context, assetType types.AssetType, version uint64) *types.Vault { for _, v := range k.GetParams(ctx).Vaults { diff --git a/x/btcbridge/keeper/queries.go b/x/btcbridge/keeper/queries.go index 13a7f966..4adb11cd 100644 --- a/x/btcbridge/keeper/queries.go +++ b/x/btcbridge/keeper/queries.go @@ -2,7 +2,6 @@ package keeper import ( "context" - "strconv" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" @@ -66,6 +65,18 @@ func (k Keeper) QueryBlockHeaderByHeight(goCtx context.Context, req *types.Query return &types.QueryBlockHeaderByHeightResponse{BlockHeader: header}, nil } +func (k Keeper) QueryFeeRate(goCtx context.Context, req *types.QueryFeeRateRequest) (*types.QueryFeeRateResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + + ctx := sdk.UnwrapSDKContext(goCtx) + + feeRate := k.GetFeeRate(ctx) + + return &types.QueryFeeRateResponse{FeeRate: feeRate}, nil +} + func (k Keeper) QuerySigningRequests(goCtx context.Context, req *types.QuerySigningRequestsRequest) (*types.QuerySigningRequestsResponse, error) { if req == nil { return nil, status.Error(codes.InvalidArgument, "invalid request") @@ -109,35 +120,6 @@ func (k Keeper) QuerySigningRequestByTxHash(goCtx context.Context, req *types.Qu return &types.QuerySigningRequestByTxHashResponse{Request: request}, nil } -func (k Keeper) QueryWithdrawNetworkFee(goCtx context.Context, req *types.QueryWithdrawNetworkFeeRequest) (*types.QueryWithdrawNetworkFeeResponse, error) { - if req == nil { - return nil, status.Error(codes.InvalidArgument, "invalid request") - } - ctx := sdk.UnwrapSDKContext(goCtx) - - amount, err := sdk.ParseCoinNormalized(req.Amount) - if err != nil { - return nil, err - } - - feeRate, err := strconv.ParseInt(req.FeeRate, 10, 64) - if err != nil { - return nil, types.ErrInvalidFeeRate - } - - signingReq, err := k.NewSigningRequest(ctx, req.Sender, amount, feeRate) - if err != nil { - return nil, err - } - - fee, err := k.getBtcNetworkFee(ctx, signingReq.Psbt) - if err != nil { - return nil, err - } - - return &types.QueryWithdrawNetworkFeeResponse{Fee: fee.Amount.Int64()}, nil -} - func (k Keeper) QueryUTXOs(goCtx context.Context, req *types.QueryUTXOsRequest) (*types.QueryUTXOsResponse, error) { if req == nil { return nil, status.Error(codes.InvalidArgument, "invalid request") diff --git a/x/btcbridge/keeper/tss.go b/x/btcbridge/keeper/tss.go index 32c08119..dd7c6177 100644 --- a/x/btcbridge/keeper/tss.go +++ b/x/btcbridge/keeper/tss.go @@ -279,7 +279,7 @@ func (k Keeper) TransferVault(ctx sdk.Context, sourceVersion uint64, destVersion signingReq := &types.SigningRequest{ Address: k.authority, - Sequence: k.IncrementRequestSequence(ctx), + Sequence: k.IncrementSigningRequestSequence(ctx), Txid: p.UnsignedTx.TxHash().String(), Psbt: psbts[i], Status: types.SigningStatus_SIGNING_STATUS_PENDING, @@ -317,6 +317,10 @@ func (k Keeper) TransferVault(ctx sdk.Context, sourceVersion uint64, destVersion // handleTransferVaultTx handles the pre-built tx for the vault transfer func (k Keeper) handleTransferVaultTx(ctx sdk.Context, p *psbt.Packet, sourceVault, destVault *types.Vault, assetType types.AssetType) error { + if err := k.checkUtxoCount(ctx, len(p.UnsignedTx.TxIn)); err != nil { + return err + } + txHash := p.UnsignedTx.TxHash().String() if assetType == types.AssetType_ASSET_TYPE_RUNES { @@ -440,6 +444,10 @@ func (k Keeper) BuildTransferVaultBtcSigningRequest(ctx sdk.Context, sourceVault return nil, types.ErrInsufficientUTXOs } + if err := k.checkUtxos(ctx, utxos); err != nil { + return nil, err + } + p, recipientUTXO, err := types.BuildTransferAllBtcPsbt(utxos, destVault.Address, feeRate) if err != nil { return nil, err @@ -459,7 +467,7 @@ func (k Keeper) BuildTransferVaultBtcSigningRequest(ctx sdk.Context, sourceVault signingReq := &types.SigningRequest{ Address: k.authority, - Sequence: k.IncrementRequestSequence(ctx), + Sequence: k.IncrementSigningRequestSequence(ctx), Txid: p.UnsignedTx.TxHash().String(), Psbt: psbtB64, Status: types.SigningStatus_SIGNING_STATUS_PENDING, @@ -505,6 +513,10 @@ func (k Keeper) BuildTransferVaultRunesSigningRequest(ctx sdk.Context, sourceVau return nil, err } + if err := k.checkUtxos(ctx, runesUtxos, selectedUtxos); err != nil { + return nil, err + } + psbtB64, err := p.B64Encode() if err != nil { return nil, types.ErrFailToSerializePsbt @@ -527,7 +539,7 @@ func (k Keeper) BuildTransferVaultRunesSigningRequest(ctx sdk.Context, sourceVau signingReq := &types.SigningRequest{ Address: k.authority, - Sequence: k.IncrementRequestSequence(ctx), + Sequence: k.IncrementSigningRequestSequence(ctx), Txid: p.UnsignedTx.TxHash().String(), Psbt: psbtB64, Status: types.SigningStatus_SIGNING_STATUS_PENDING, diff --git a/x/btcbridge/keeper/utxo.go b/x/btcbridge/keeper/utxo.go index 2f9e26ea..abb95822 100644 --- a/x/btcbridge/keeper/utxo.go +++ b/x/btcbridge/keeper/utxo.go @@ -2,7 +2,6 @@ package keeper import ( "math/big" - "sort" "lukechampine.com/uint128" @@ -23,7 +22,6 @@ type UTXOViewKeeper interface { GetUTXOsByAddr(ctx sdk.Context, addr string) []*types.UTXO GetUTXOIteratorByAddr(ctx sdk.Context, addr string) types.UTXOIterator GetUnlockedUTXOsByAddr(ctx sdk.Context, addr string) []*types.UTXO - GetOrderedUTXOsByAddr(ctx sdk.Context, addr string) []*types.UTXO GetTargetRunesUTXOs(ctx sdk.Context, addr string, runeId string, targetAmount uint128.Uint128) ([]*types.UTXO, []*types.RuneBalance) @@ -109,7 +107,7 @@ func (bvk *BaseUTXOViewKeeper) GetUTXOsByAddr(ctx sdk.Context, addr string) []*t func (bvk *BaseUTXOViewKeeper) GetUTXOIteratorByAddr(ctx sdk.Context, addr string) types.UTXOIterator { store := ctx.KVStore(bvk.storeKey) - iterator := sdk.KVStorePrefixIterator(store, append(types.BtcOwnerUtxoKeyPrefix, []byte(addr)...)) + iterator := sdk.KVStoreReversePrefixIterator(store, append(types.BtcOwnerUtxoByAmountKeyPrefix, []byte(addr)...)) return &UTXOIterator{ ctx: ctx, @@ -151,22 +149,6 @@ func (bvk *BaseUTXOViewKeeper) GetUnlockedUTXOsByAddrAndThreshold(ctx sdk.Contex return utxos } -// GetOrderedUTXOsByAddr gets all unlocked utxos of the given address in the descending order by amount -// Note: high gas is required due to sorting -func (bvk *BaseUTXOViewKeeper) GetOrderedUTXOsByAddr(ctx sdk.Context, addr string) []*types.UTXO { - // get unlocked utxos - utxos := bvk.GetUnlockedUTXOsByAddr(ctx, addr) - - if len(utxos) > 1 { - // sort utxos in the descending order - sort.SliceStable(utxos, func(i int, j int) bool { - return utxos[i].Amount > utxos[j].Amount - }) - } - - return utxos -} - // GetTargetRunesUTXOs gets the unlocked runes utxos targeted by the given params func (bvk *BaseUTXOViewKeeper) GetTargetRunesUTXOs(ctx sdk.Context, addr string, runeId string, targetAmount uint128.Uint128) ([]*types.UTXO, []*types.RuneBalance) { utxos := make([]*types.UTXO, 0) @@ -321,6 +303,12 @@ func (bk *BaseUTXOKeeper) SetOwnerUTXO(ctx sdk.Context, utxo *types.UTXO) { store.Set(types.BtcOwnerUtxoKey(utxo.Address, utxo.Txid, utxo.Vout), []byte{}) } +func (bk *BaseUTXOKeeper) SetOwnerUTXOByAmount(ctx sdk.Context, utxo *types.UTXO) { + store := ctx.KVStore(bk.storeKey) + + store.Set(types.BtcOwnerUtxoByAmountKey(utxo.Address, utxo.Amount, utxo.Txid, utxo.Vout), []byte{}) +} + func (bk *BaseUTXOKeeper) SetOwnerRunesUTXO(ctx sdk.Context, utxo *types.UTXO, id string, amount string) { store := ctx.KVStore(bk.storeKey) @@ -409,6 +397,7 @@ func (bk *BaseUTXOKeeper) SaveUTXO(ctx sdk.Context, utxo *types.UTXO) { func (bk *BaseUTXOKeeper) saveUTXO(ctx sdk.Context, utxo *types.UTXO) { bk.SetUTXO(ctx, utxo) bk.SetOwnerUTXO(ctx, utxo) + bk.SetOwnerUTXOByAmount(ctx, utxo) for _, r := range utxo.Runes { bk.SetOwnerRunesUTXO(ctx, utxo, r.Id, r.Amount) @@ -422,13 +411,15 @@ func (bk *BaseUTXOKeeper) removeUTXO(ctx sdk.Context, hash string, vout uint64) store.Delete(types.BtcUtxoKey(hash, vout)) store.Delete(types.BtcOwnerUtxoKey(utxo.Address, hash, vout)) + store.Delete(types.BtcOwnerUtxoByAmountKey(utxo.Address, utxo.Amount, hash, vout)) for _, r := range utxo.Runes { store.Delete(types.BtcOwnerRunesUtxoKey(utxo.Address, r.Id, hash, vout)) } } -// UTXOIterator defines the iterator over utxos by address +// UTXOIterator implements types.UTXOIterator +// The iterator iterates over utxos by address and amount type UTXOIterator struct { ctx sdk.Context keeper UTXOViewKeeper @@ -451,9 +442,10 @@ func (i *UTXOIterator) Close() error { func (i *UTXOIterator) GetUTXO() *types.UTXO { key := i.iterator.Key() + prefixLen := 1 + len(i.address) + 8 - hash := key[1+len(i.address) : 1+len(i.address)+64] - vout := key[1+len(i.address)+64:] + hash := key[prefixLen : prefixLen+64] + vout := key[prefixLen+64:] - return i.keeper.GetUTXO(i.ctx, string(hash), new(big.Int).SetBytes(vout).Uint64()) + return i.keeper.GetUTXO(i.ctx, string(hash), sdk.BigEndianToUint64(vout)) } diff --git a/x/btcbridge/keeper/withdraw.go b/x/btcbridge/keeper/withdraw.go index 41aa269a..a4de6394 100644 --- a/x/btcbridge/keeper/withdraw.go +++ b/x/btcbridge/keeper/withdraw.go @@ -10,28 +10,135 @@ import ( "github.com/btcsuite/btcd/chaincfg/chainhash" sdk "github.com/cosmos/cosmos-sdk/types" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" "github.com/sideprotocol/side/x/btcbridge/types" ) -// GetRequestSequence returns the request sequence -func (k Keeper) GetRequestSequence(ctx sdk.Context) uint64 { +// IncreaseWithdrawRequestSequence increases the withdrawal request sequence by 1 +func (k Keeper) IncreaseWithdrawRequestSequence(ctx sdk.Context) uint64 { store := ctx.KVStore(k.storeKey) - bz := store.Get(types.SequenceKey) + + sequence := k.GetWithdrawSequence(ctx) + store.Set(types.BtcWithdrawRequestSequenceKey, sdk.Uint64ToBigEndian(sequence+1)) + + return sequence + 1 +} + +// GetWithdrawRequestSequence gets the withdrawal request sequence +func (k Keeper) GetWithdrawSequence(ctx sdk.Context) uint64 { + store := ctx.KVStore(k.storeKey) + + bz := store.Get(types.BtcWithdrawRequestSequenceKey) + if bz != nil { + return sdk.BigEndianToUint64(bz) + } + + return 0 +} + +// GetSigningRequestSequence returns the signing request sequence +func (k Keeper) GetSigningRequestSequence(ctx sdk.Context) uint64 { + store := ctx.KVStore(k.storeKey) + + bz := store.Get(types.BtcSigningRequestSequenceKey) if bz == nil { return 0 } + return sdk.BigEndianToUint64(bz) } -// IncrementRequestSequence increments the request sequence and returns the new sequence -func (k Keeper) IncrementRequestSequence(ctx sdk.Context) uint64 { +// IncrementSigningRequestSequence increments the signing request sequence and returns the new sequence +func (k Keeper) IncrementSigningRequestSequence(ctx sdk.Context) uint64 { store := ctx.KVStore(k.storeKey) - seq := k.GetRequestSequence(ctx) + 1 - store.Set(types.SequenceKey, sdk.Uint64ToBigEndian(seq)) + + seq := k.GetSigningRequestSequence(ctx) + 1 + store.Set(types.BtcSigningRequestSequenceKey, sdk.Uint64ToBigEndian(seq)) + return seq } +// HandleWithdrawal handles the given withdrawal request +func (k Keeper) HandleWithdrawal(ctx sdk.Context, sender string, amount sdk.Coin) (*types.WithdrawRequest, error) { + switch types.AssetTypeFromDenom(amount.Denom, k.GetParams(ctx)) { + case types.AssetType_ASSET_TYPE_BTC: + return k.HandleBtcWithdrawal(ctx, sender, amount) + + case types.AssetType_ASSET_TYPE_RUNES: + return k.HandleRunesWithdrawal(ctx, sender, amount) + + default: + return nil, types.ErrAssetNotSupported + } +} + +// HandleBtcWithdrawal handles the given btc withdrawal request +// Btc withdrawal request will be dispatched to the batch withdrawal queue which is handled periodically +func (k Keeper) HandleBtcWithdrawal(ctx sdk.Context, sender string, amount sdk.Coin) (*types.WithdrawRequest, error) { + // set the withdrawal request + withdrawRequest := k.NewWithdrawRequest(ctx, sender, amount.String()) + k.SetWithdrawRequest(ctx, withdrawRequest) + + // add to the pending queue + k.AddToBtcWithdrawRequestQueue(ctx, withdrawRequest) + + // burn asset + if err := k.BurnAsset(ctx, sender, amount); err != nil { + return nil, err + } + + return withdrawRequest, nil +} + +// HandleRunesWithdrawal handles the given runes withdrawal request +// Runes withdrawal will generate a signing request immediately +func (k Keeper) HandleRunesWithdrawal(ctx sdk.Context, sender string, amount sdk.Coin) (*types.WithdrawRequest, error) { + // build the withdrawal request + withdrawRequest := k.NewWithdrawRequest(ctx, sender, amount.String()) + + // build the signing request + + vaults := k.GetParams(ctx).Vaults + btcVault := types.SelectVaultByAssetType(vaults, types.AssetType_ASSET_TYPE_BTC) + runesVault := types.SelectVaultByAssetType(vaults, types.AssetType_ASSET_TYPE_RUNES) + + feeRate := k.GetFeeRate(ctx) + if feeRate == 0 { + return nil, types.ErrInvalidFeeRate + } + + signingRequest, err := k.NewRunesSigningRequest(ctx, sender, amount, feeRate, runesVault.Address, btcVault.Address) + if err != nil { + return nil, err + } + + // set the withdrawal request + withdrawRequest.Txid = signingRequest.Txid + k.SetWithdrawRequest(ctx, withdrawRequest) + + // burn asset + if err := k.BurnAsset(ctx, sender, amount); err != nil { + return nil, err + } + + // burn btc network fee + if err := k.BurnBtcNetworkFee(ctx, signingRequest.Psbt); err != nil { + return nil, err + } + + return withdrawRequest, nil +} + +// NewWithdrawRequest builds a new withdrawal request +func (k Keeper) NewWithdrawRequest(ctx sdk.Context, sender string, amount string) *types.WithdrawRequest { + return &types.WithdrawRequest{ + Address: sender, + Amount: amount, + Sequence: k.IncreaseWithdrawRequestSequence(ctx), + } +} + // NewSigningRequest creates a new withdrawal request func (k Keeper) NewSigningRequest(ctx sdk.Context, sender string, amount sdk.Coin, feeRate int64) (*types.SigningRequest, error) { p := k.GetParams(ctx) @@ -59,6 +166,10 @@ func (k Keeper) NewBtcSigningRequest(ctx sdk.Context, sender string, amount sdk. return nil, err } + if err := k.checkUtxos(ctx, selectedUTXOs); err != nil { + return nil, err + } + psbtB64, err := psbt.B64Encode() if err != nil { return nil, types.ErrFailToSerializePsbt @@ -75,7 +186,7 @@ func (k Keeper) NewBtcSigningRequest(ctx sdk.Context, sender string, amount sdk. signingRequest := &types.SigningRequest{ Address: sender, - Sequence: k.IncrementRequestSequence(ctx), + Sequence: k.IncrementSigningRequestSequence(ctx), Txid: psbt.UnsignedTx.TxHash().String(), Psbt: psbtB64, Status: types.SigningStatus_SIGNING_STATUS_PENDING, @@ -105,6 +216,10 @@ func (k Keeper) NewRunesSigningRequest(ctx sdk.Context, sender string, amount sd return nil, err } + if err := k.checkUtxos(ctx, runesUTXOs, selectedUTXOs); err != nil { + return nil, err + } + psbtB64, err := psbt.B64Encode() if err != nil { return nil, types.ErrFailToSerializePsbt @@ -128,7 +243,7 @@ func (k Keeper) NewRunesSigningRequest(ctx sdk.Context, sender string, amount sd signingRequest := &types.SigningRequest{ Address: sender, - Sequence: k.IncrementRequestSequence(ctx), + Sequence: k.IncrementSigningRequestSequence(ctx), Txid: psbt.UnsignedTx.TxHash().String(), Psbt: psbtB64, Status: types.SigningStatus_SIGNING_STATUS_PENDING, @@ -139,6 +254,191 @@ func (k Keeper) NewRunesSigningRequest(ctx sdk.Context, sender string, amount sd return signingRequest, nil } +// BuildBtcBatchWithdrawSigningRequest builds the signing request for btc batch withdrawal +func (k Keeper) BuildBtcBatchWithdrawSigningRequest(ctx sdk.Context, withdrawRequests []*types.WithdrawRequest, feeRate int64, vault string) (*types.SigningRequest, error) { + utxoIterator := k.GetUTXOIteratorByAddr(ctx, vault) + + psbt, selectedUTXOs, changeUTXO, err := types.BuildBtcBatchWithdrawPsbt(utxoIterator, withdrawRequests, feeRate, vault) + if err != nil { + return nil, err + } + + if err := k.checkUtxos(ctx, selectedUTXOs); err != nil { + return nil, err + } + + psbtB64, err := psbt.B64Encode() + if err != nil { + return nil, types.ErrFailToSerializePsbt + } + + // first burn btc network fee to prevent the following state change when an error returned + // avoid panic in EndBlocker + if err := k.BurnBtcNetworkFee(ctx, psbtB64); err != nil { + return nil, err + } + + // lock the selected utxos + _ = k.LockUTXOs(ctx, selectedUTXOs) + + // save the change utxo and mark minted + if changeUTXO != nil { + k.saveUTXO(ctx, changeUTXO) + k.addToMintHistory(ctx, psbt.UnsignedTx.TxHash().String()) + } + + signingRequest := &types.SigningRequest{ + Address: authtypes.NewModuleAddress(types.ModuleName).String(), + Sequence: k.IncrementSigningRequestSequence(ctx), + Txid: psbt.UnsignedTx.TxHash().String(), + Psbt: psbtB64, + Status: types.SigningStatus_SIGNING_STATUS_PENDING, + } + + k.SetSigningRequest(ctx, signingRequest) + + return signingRequest, nil +} + +// GetWithdrawRequest gets the withdrawal request by the given sequence +func (k Keeper) GetWithdrawRequest(ctx sdk.Context, sequence uint64) *types.WithdrawRequest { + store := ctx.KVStore(k.storeKey) + + bz := store.Get(types.BtcWithdrawRequestKey(sequence)) + var req types.WithdrawRequest + k.cdc.MustUnmarshal(bz, &req) + + return &req +} + +// GetWithdrawRequestsByAddress gets the withdrawal requests by the given address +func (k Keeper) GetWithdrawRequestsByAddress(ctx sdk.Context, address string) []*types.WithdrawRequest { + requests := make([]*types.WithdrawRequest, 0) + + k.IterateWithdrawRequests(ctx, func(req *types.WithdrawRequest) (stop bool) { + if req.Address != address { + return false + } + + requests = append(requests, req) + + // TODO: pagination + return len(requests) >= 100 + }) + + return requests +} + +// GetPendingBtcWithdrawRequests gets the pending btc withdrawal requests up to the given maximum number +func (k Keeper) GetPendingBtcWithdrawRequests(ctx sdk.Context, maxNum uint32) []*types.WithdrawRequest { + requests := make([]*types.WithdrawRequest, 0) + + k.IterateBtcWithdrawRequestQueue(ctx, func(req *types.WithdrawRequest) (stop bool) { + requests = append(requests, req) + + return len(requests) >= int(maxNum) + }) + + return requests +} + +// GetWithdrawRequestsByTxHash gets the withdrawal requests by the given tx hash +func (k Keeper) GetWithdrawRequestsByTxHash(ctx sdk.Context, txHash string) []*types.WithdrawRequest { + requests := make([]*types.WithdrawRequest, 0) + + k.IterateWithdrawRequestsByTxHash(ctx, txHash, func(req *types.WithdrawRequest) (stop bool) { + requests = append(requests, req) + + return false + }) + + return requests +} + +// SetWithdrawRequest sets the given withdrawal request +func (k Keeper) SetWithdrawRequest(ctx sdk.Context, req *types.WithdrawRequest) { + store := ctx.KVStore(k.storeKey) + + bz := k.cdc.MustMarshal(req) + store.Set(types.BtcWithdrawRequestKey(req.Sequence), bz) + + if len(req.Txid) > 0 { + k.SetWithdrawRequestByTxHash(ctx, req) + } +} + +// SetWithdrawRequestByTxHash sets the given withdrawal request by tx hash +func (k Keeper) SetWithdrawRequestByTxHash(ctx sdk.Context, req *types.WithdrawRequest) { + store := ctx.KVStore(k.storeKey) + + store.Set(types.BtcWithdrawRequestByTxHashKey(req.Txid, req.Sequence), []byte{}) +} + +// AddToBtcWithdrawRequestQueue adds the given btc withdrawal request to the pending queue +func (k Keeper) AddToBtcWithdrawRequestQueue(ctx sdk.Context, req *types.WithdrawRequest) { + store := ctx.KVStore(k.storeKey) + + store.Set(types.BtcWithdrawRequestQueueKey(req.Sequence), []byte{}) +} + +// RemoveFromBtcWithdrawRequestQueue removes the given btc withdrawal request from the pending queue +func (k Keeper) RemoveFromBtcWithdrawRequestQueue(ctx sdk.Context, req *types.WithdrawRequest) { + store := ctx.KVStore(k.storeKey) + + store.Delete(types.BtcWithdrawRequestQueueKey(req.Sequence)) +} + +// IterateWithdrawRequests iterates through all withdrawal requests +func (k Keeper) IterateWithdrawRequests(ctx sdk.Context, cb func(req *types.WithdrawRequest) (stop bool)) { + store := ctx.KVStore(k.storeKey) + + iterator := sdk.KVStorePrefixIterator(store, types.BtcWithdrawRequestKeyPrefix) + defer iterator.Close() + + for ; iterator.Valid(); iterator.Next() { + var request types.WithdrawRequest + k.cdc.MustUnmarshal(iterator.Value(), &request) + + if cb(&request) { + break + } + } +} + +// IterateWithdrawRequestsByTxHash iterates through all withdrawal requests by the given tx hash +func (k Keeper) IterateWithdrawRequestsByTxHash(ctx sdk.Context, txHash string, cb func(req *types.WithdrawRequest) (stop bool)) { + store := ctx.KVStore(k.storeKey) + + iterator := sdk.KVStorePrefixIterator(store, append(types.BtcWithdrawRequestByTxHashKeyPrefix, []byte(txHash)...)) + defer iterator.Close() + + for ; iterator.Valid(); iterator.Next() { + sequence := sdk.BigEndianToUint64(iterator.Key()[1+64:]) + request := k.GetWithdrawRequest(ctx, sequence) + + if cb(request) { + break + } + } +} + +// IterateBtcWithdrawRequestQueue iterates through the btc withdrawal request queue +func (k Keeper) IterateBtcWithdrawRequestQueue(ctx sdk.Context, cb func(req *types.WithdrawRequest) (stop bool)) { + store := ctx.KVStore(k.storeKey) + + iterator := sdk.KVStorePrefixIterator(store, types.BtcWithdrawRequestQueueKeyPrefix) + defer iterator.Close() + + for ; iterator.Valid(); iterator.Next() { + sequence := sdk.BigEndianToUint64(iterator.Key()[1:]) + request := k.GetWithdrawRequest(ctx, sequence) + + if cb(request) { + break + } + } +} + // HasSigningRequest returns true if the given signing request exists, false otherwise func (k Keeper) HasSigningRequest(ctx sdk.Context, sequence uint64) bool { store := ctx.KVStore(k.storeKey) @@ -162,7 +462,7 @@ func (k Keeper) GetSigningRequest(ctx sdk.Context, sequence uint64) *types.Signi return &signingRequest } -// GetSigningRequestByTxHash returns the withdrawal request by the given hash +// GetSigningRequestByTxHash returns the signing request by the given hash func (k Keeper) GetSigningRequestByTxHash(ctx sdk.Context, hash string) *types.SigningRequest { store := ctx.KVStore(k.storeKey) @@ -174,7 +474,7 @@ func (k Keeper) GetSigningRequestByTxHash(ctx sdk.Context, hash string) *types.S return nil } -// SetSigningRequest sets the withdrawal request +// SetSigningRequest sets the signing request func (k Keeper) SetSigningRequest(ctx sdk.Context, signingRequest *types.SigningRequest) { store := ctx.KVStore(k.storeKey) @@ -184,7 +484,7 @@ func (k Keeper) SetSigningRequest(ctx sdk.Context, signingRequest *types.Signing store.Set(types.BtcSigningRequestByTxHashKey(signingRequest.Txid), sdk.Uint64ToBigEndian(signingRequest.Sequence)) } -// IterateSigningRequests iterates through all withdrawal requests +// IterateSigningRequests iterates through all signing requests func (k Keeper) IterateSigningRequests(ctx sdk.Context, cb func(signingRequest *types.SigningRequest) (stop bool)) { store := ctx.KVStore(k.storeKey) @@ -201,7 +501,7 @@ func (k Keeper) IterateSigningRequests(ctx sdk.Context, cb func(signingRequest * } } -// FilterSigningRequestsByStatus filters withdrawal requests by status with pagination +// FilterSigningRequestsByStatus filters signing requests by status with pagination func (k Keeper) FilterSigningRequestsByStatus(ctx sdk.Context, req *types.QuerySigningRequestsRequest) []*types.SigningRequest { var signingRequests []*types.SigningRequest @@ -210,7 +510,7 @@ func (k Keeper) FilterSigningRequestsByStatus(ctx sdk.Context, req *types.QueryS signingRequests = append(signingRequests, signingRequest) } - // pagination TODO: limit the number of withdrawal requests + // pagination TODO: limit the number of signing requests if len(signingRequests) >= 100 { return true } @@ -267,45 +567,42 @@ func (k Keeper) ProcessBitcoinWithdrawTransaction(ctx sdk.Context, msg *types.Ms // spend the locked utxos k.spendUTXOs(ctx, tx) - // burn the locked assets - if err := k.burnLockedAssets(ctx, txHash.String()); err != nil { - return nil, err - } - return txHash, nil } -// LockAssets locks the related assets for the given signing request -func (k Keeper) LockAssets(ctx sdk.Context, req *types.SigningRequest, amount sdk.Coin) error { - btcNetworkFee, err := k.getBtcNetworkFee(ctx, req.Psbt) - if err != nil { - return err +// spendUTXOs spends locked utxos +func (k Keeper) spendUTXOs(ctx sdk.Context, uTx *btcutil.Tx) { + for _, in := range uTx.MsgTx().TxIn { + hash := in.PreviousOutPoint.Hash.String() + vout := in.PreviousOutPoint.Index + + if k.IsUTXOLocked(ctx, hash, uint64(vout)) { + _ = k.SpendUTXO(ctx, hash, uint64(vout)) + } } +} - if err = k.bankKeeper.SendCoinsFromAccountToModule(ctx, sdk.MustAccAddressFromBech32(req.Address), types.ModuleName, sdk.NewCoins(amount)); err != nil { +// BurnAsset burns the asset related to the withdrawal +func (k Keeper) BurnAsset(ctx sdk.Context, address string, amount sdk.Coin) error { + if err := k.bankKeeper.SendCoinsFromAccountToModule(ctx, sdk.MustAccAddressFromBech32(address), types.ModuleName, sdk.NewCoins(amount)); err != nil { return err } - if err = k.bankKeeper.SendCoinsFromAccountToModule(ctx, sdk.MustAccAddressFromBech32(req.Address), types.ModuleName, sdk.NewCoins(btcNetworkFee)); err != nil { + if err := k.bankKeeper.BurnCoins(ctx, types.ModuleName, sdk.NewCoins(amount)); err != nil { return err } - // mark locked assets which will be burned when the withdrawal tx is relayed back - k.lockAssets(ctx, req.Txid, amount, btcNetworkFee) - return nil } -// spendUTXOs spends locked utxos -func (k Keeper) spendUTXOs(ctx sdk.Context, uTx *btcutil.Tx) { - for _, in := range uTx.MsgTx().TxIn { - hash := in.PreviousOutPoint.Hash.String() - vout := in.PreviousOutPoint.Index - - if k.IsUTXOLocked(ctx, hash, uint64(vout)) { - _ = k.SpendUTXO(ctx, hash, uint64(vout)) - } +// BurnBtcNetworkFee burns the bitcoin network fee of the withdrawal psbt +func (k Keeper) BurnBtcNetworkFee(ctx sdk.Context, packet string) error { + networkFee, err := k.getBtcNetworkFee(ctx, packet) + if err != nil { + return err } + + return k.BurnAsset(ctx, k.ProtocolFeeCollector(ctx), networkFee) } // handleWithdrawProtocolFee performs the protocol fee handling and returns the actual withdrawal amount @@ -347,32 +644,22 @@ func (k Keeper) getBtcNetworkFee(ctx sdk.Context, packet string) (sdk.Coin, erro return sdk.NewCoin(k.GetParams(ctx).BtcVoucherDenom, sdk.NewInt(int64(txFee))), nil } -// lockAssets locks the given assets by the tx hash -func (k Keeper) lockAssets(ctx sdk.Context, txHash string, coins ...sdk.Coin) { - store := ctx.KVStore(k.storeKey) +// checkUtxos checks if the total count of the given utxos exceeds the allowed maximum number +func (k Keeper) checkUtxos(ctx sdk.Context, utxoSets ...[]*types.UTXO) error { + count := 0 - for i, coin := range coins { - bz := k.cdc.MustMarshal(&coin) - store.Set(types.BtcLockedAssetKey(txHash, uint8(i)), bz) + for _, utxoSet := range utxoSets { + count += len(utxoSet) } -} - -// burnLockedAssets burns the locked assets -func (k Keeper) burnLockedAssets(ctx sdk.Context, txHash string) error { - store := ctx.KVStore(k.storeKey) - iterator := sdk.KVStorePrefixIterator(store, append(types.BtcLockedAssetKeyPrefix, []byte(txHash)...)) - defer iterator.Close() - - for ; iterator.Valid(); iterator.Next() { - var lockedAsset sdk.Coin - k.cdc.MustUnmarshal(iterator.Value(), &lockedAsset) - - if err := k.bankKeeper.BurnCoins(ctx, types.ModuleName, sdk.NewCoins(lockedAsset)); err != nil { - return err - } + return k.checkUtxoCount(ctx, count) +} - store.Delete(iterator.Key()) +// checkUtxoCount checks if the given utxo count exceeds the allowed maximum number +func (k Keeper) checkUtxoCount(ctx sdk.Context, utxoCount int) error { + maxUtxoNum := k.GetParams(ctx).WithdrawParams.MaxUtxoNum + if maxUtxoNum != 0 && utxoCount > int(maxUtxoNum) { + return types.ErrMaxUTXONumExceeded } return nil diff --git a/x/btcbridge/types/bitcoin.go b/x/btcbridge/types/bitcoin.go index 7c3ac543..316aa621 100644 --- a/x/btcbridge/types/bitcoin.go +++ b/x/btcbridge/types/bitcoin.go @@ -107,6 +107,42 @@ func BuildTransferAllBtcPsbt(utxos []*UTXO, recipient string, feeRate int64) (*p return p, recipientUTXO, nil } +// BuildBtcBatchWithdrawPsbt builds the psbt to perform btc batch withdrawal +func BuildBtcBatchWithdrawPsbt(utxoIterator UTXOIterator, withdrawRequests []*WithdrawRequest, feeRate int64, change string) (*psbt.Packet, []*UTXO, *UTXO, error) { + chainCfg := sdk.GetConfig().GetBtcChainCfg() + + txOuts := make([]*wire.TxOut, len(withdrawRequests)) + + for _, req := range withdrawRequests { + amount, _ := sdk.ParseCoinNormalized(req.Amount) + + address, _ := btcutil.DecodeAddress(req.Address, chainCfg) + pkScript, _ := txscript.PayToAddrScript(address) + + txOut := wire.NewTxOut(int64(amount.Amount.Uint64()), pkScript) + txOuts = append(txOuts, txOut) + } + + changeAddress, _ := btcutil.DecodeAddress(change, chainCfg) + + unsignedTx, selectedUTXOs, changeUTXO, err := BuildUnsignedTransaction([]*UTXO{}, txOuts, utxoIterator, feeRate, changeAddress) + if err != nil { + return nil, nil, nil, err + } + + p, err := psbt.NewFromUnsignedTx(unsignedTx) + if err != nil { + return nil, nil, nil, err + } + + for i, utxo := range selectedUTXOs { + p.Inputs[i].SighashType = DefaultSigHashType + p.Inputs[i].WitnessUtxo = wire.NewTxOut(int64(utxo.Amount), utxo.PubKeyScript) + } + + return p, selectedUTXOs, changeUTXO, nil +} + // BuildRunesPsbt builds a bitcoin psbt for runes edict from the given params. // Assume that the utxo script type is witness. func BuildRunesPsbt(utxos []*UTXO, paymentUTXOIterator UTXOIterator, recipient string, runeId string, amount uint128.Uint128, feeRate int64, runeBalancesDelta []*RuneBalance, runesChange string, change string) (*psbt.Packet, []*UTXO, *UTXO, *UTXO, error) { diff --git a/x/btcbridge/types/btcbridge.pb.go b/x/btcbridge/types/btcbridge.pb.go index 1cdc4d63..e3a9c4d0 100644 --- a/x/btcbridge/types/btcbridge.pb.go +++ b/x/btcbridge/types/btcbridge.pb.go @@ -295,6 +295,75 @@ func (m *SigningRequest) GetStatus() SigningStatus { return SigningStatus_SIGNING_STATUS_UNSPECIFIED } +// Withdrawal Request +type WithdrawRequest struct { + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + Amount string `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"` + Sequence uint64 `protobuf:"varint,3,opt,name=sequence,proto3" json:"sequence,omitempty"` + Txid string `protobuf:"bytes,4,opt,name=txid,proto3" json:"txid,omitempty"` +} + +func (m *WithdrawRequest) Reset() { *m = WithdrawRequest{} } +func (m *WithdrawRequest) String() string { return proto.CompactTextString(m) } +func (*WithdrawRequest) ProtoMessage() {} +func (*WithdrawRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_9ff68b16012a2359, []int{2} +} +func (m *WithdrawRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WithdrawRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_WithdrawRequest.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 *WithdrawRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_WithdrawRequest.Merge(m, src) +} +func (m *WithdrawRequest) XXX_Size() int { + return m.Size() +} +func (m *WithdrawRequest) XXX_DiscardUnknown() { + xxx_messageInfo_WithdrawRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_WithdrawRequest proto.InternalMessageInfo + +func (m *WithdrawRequest) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +func (m *WithdrawRequest) GetAmount() string { + if m != nil { + return m.Amount + } + return "" +} + +func (m *WithdrawRequest) GetSequence() uint64 { + if m != nil { + return m.Sequence + } + return 0 +} + +func (m *WithdrawRequest) GetTxid() string { + if m != nil { + return m.Txid + } + return "" +} + // Bitcoin UTXO type UTXO struct { Txid string `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"` @@ -312,7 +381,7 @@ func (m *UTXO) Reset() { *m = UTXO{} } func (m *UTXO) String() string { return proto.CompactTextString(m) } func (*UTXO) ProtoMessage() {} func (*UTXO) Descriptor() ([]byte, []int) { - return fileDescriptor_9ff68b16012a2359, []int{2} + return fileDescriptor_9ff68b16012a2359, []int{3} } func (m *UTXO) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -409,7 +478,7 @@ func (m *RuneBalance) Reset() { *m = RuneBalance{} } func (m *RuneBalance) String() string { return proto.CompactTextString(m) } func (*RuneBalance) ProtoMessage() {} func (*RuneBalance) Descriptor() ([]byte, []int) { - return fileDescriptor_9ff68b16012a2359, []int{3} + return fileDescriptor_9ff68b16012a2359, []int{4} } func (m *RuneBalance) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -464,7 +533,7 @@ func (m *RuneId) Reset() { *m = RuneId{} } func (m *RuneId) String() string { return proto.CompactTextString(m) } func (*RuneId) ProtoMessage() {} func (*RuneId) Descriptor() ([]byte, []int) { - return fileDescriptor_9ff68b16012a2359, []int{4} + return fileDescriptor_9ff68b16012a2359, []int{5} } func (m *RuneId) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -518,7 +587,7 @@ func (m *Edict) Reset() { *m = Edict{} } func (m *Edict) String() string { return proto.CompactTextString(m) } func (*Edict) ProtoMessage() {} func (*Edict) Descriptor() ([]byte, []int) { - return fileDescriptor_9ff68b16012a2359, []int{5} + return fileDescriptor_9ff68b16012a2359, []int{6} } func (m *Edict) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -580,7 +649,7 @@ func (m *BtcConsolidation) Reset() { *m = BtcConsolidation{} } func (m *BtcConsolidation) String() string { return proto.CompactTextString(m) } func (*BtcConsolidation) ProtoMessage() {} func (*BtcConsolidation) Descriptor() ([]byte, []int) { - return fileDescriptor_9ff68b16012a2359, []int{6} + return fileDescriptor_9ff68b16012a2359, []int{7} } func (m *BtcConsolidation) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -637,7 +706,7 @@ func (m *RunesConsolidation) Reset() { *m = RunesConsolidation{} } func (m *RunesConsolidation) String() string { return proto.CompactTextString(m) } func (*RunesConsolidation) ProtoMessage() {} func (*RunesConsolidation) Descriptor() ([]byte, []int) { - return fileDescriptor_9ff68b16012a2359, []int{7} + return fileDescriptor_9ff68b16012a2359, []int{8} } func (m *RunesConsolidation) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -701,7 +770,7 @@ func (m *DKGParticipant) Reset() { *m = DKGParticipant{} } func (m *DKGParticipant) String() string { return proto.CompactTextString(m) } func (*DKGParticipant) ProtoMessage() {} func (*DKGParticipant) Descriptor() ([]byte, []int) { - return fileDescriptor_9ff68b16012a2359, []int{8} + return fileDescriptor_9ff68b16012a2359, []int{9} } func (m *DKGParticipant) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -779,7 +848,7 @@ func (m *DKGRequest) Reset() { *m = DKGRequest{} } func (m *DKGRequest) String() string { return proto.CompactTextString(m) } func (*DKGRequest) ProtoMessage() {} func (*DKGRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_9ff68b16012a2359, []int{9} + return fileDescriptor_9ff68b16012a2359, []int{10} } func (m *DKGRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -896,7 +965,7 @@ func (m *DKGCompletionRequest) Reset() { *m = DKGCompletionRequest{} } func (m *DKGCompletionRequest) String() string { return proto.CompactTextString(m) } func (*DKGCompletionRequest) ProtoMessage() {} func (*DKGCompletionRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_9ff68b16012a2359, []int{10} + return fileDescriptor_9ff68b16012a2359, []int{11} } func (m *DKGCompletionRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -965,6 +1034,7 @@ func init() { proto.RegisterEnum("side.btcbridge.DKGRequestStatus", DKGRequestStatus_name, DKGRequestStatus_value) proto.RegisterType((*BlockHeader)(nil), "side.btcbridge.BlockHeader") proto.RegisterType((*SigningRequest)(nil), "side.btcbridge.SigningRequest") + proto.RegisterType((*WithdrawRequest)(nil), "side.btcbridge.WithdrawRequest") proto.RegisterType((*UTXO)(nil), "side.btcbridge.UTXO") proto.RegisterType((*RuneBalance)(nil), "side.btcbridge.RuneBalance") proto.RegisterType((*RuneId)(nil), "side.btcbridge.RuneId") @@ -979,83 +1049,84 @@ func init() { func init() { proto.RegisterFile("side/btcbridge/btcbridge.proto", fileDescriptor_9ff68b16012a2359) } var fileDescriptor_9ff68b16012a2359 = []byte{ - // 1204 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x56, 0xcd, 0x6e, 0xdb, 0x46, - 0x10, 0x36, 0x2d, 0x59, 0x96, 0x46, 0xb1, 0xa2, 0x6c, 0x53, 0x47, 0x96, 0x13, 0xd9, 0x10, 0xda, - 0xd4, 0x4d, 0x01, 0x09, 0x71, 0x11, 0xa0, 0xe8, 0xcd, 0xb2, 0x14, 0x45, 0x70, 0x22, 0xbb, 0x2b, - 0xb9, 0x28, 0x7a, 0x21, 0x96, 0xe4, 0x5a, 0x22, 0x2c, 0x72, 0x19, 0xee, 0xd2, 0x90, 0xaf, 0x7d, - 0x82, 0xbc, 0x42, 0x81, 0xf6, 0x1d, 0xfa, 0x08, 0xb9, 0x14, 0xc8, 0xb1, 0xa7, 0xb6, 0x48, 0xee, - 0x3d, 0xf5, 0x01, 0x8a, 0xfd, 0xa1, 0xfe, 0xa0, 0xe6, 0x36, 0xf3, 0xcd, 0xec, 0xce, 0xdf, 0x37, - 0x4b, 0x42, 0x8d, 0xfb, 0x1e, 0x6d, 0x3a, 0xc2, 0x75, 0x62, 0xdf, 0x1b, 0x2d, 0x48, 0x8d, 0x28, - 0x66, 0x82, 0xa1, 0x92, 0xb4, 0x37, 0x66, 0x68, 0xf5, 0xfe, 0x88, 0x8d, 0x98, 0x32, 0x35, 0xa5, - 0xa4, 0xbd, 0xaa, 0x7b, 0x23, 0xc6, 0x46, 0x13, 0xda, 0x54, 0x9a, 0x93, 0x5c, 0x35, 0x49, 0x78, - 0x6b, 0x4c, 0x07, 0xab, 0x26, 0xe1, 0x07, 0x94, 0x0b, 0x12, 0x44, 0xc6, 0xa1, 0xe6, 0x32, 0x1e, - 0x30, 0xde, 0x74, 0x08, 0xa7, 0xcd, 0x9b, 0xa7, 0x0e, 0x15, 0xe4, 0x69, 0xd3, 0x65, 0x7e, 0x98, - 0xde, 0xad, 0xed, 0xb6, 0x0e, 0xaa, 0x15, 0x63, 0xda, 0x5f, 0x49, 0x3e, 0x22, 0x31, 0x09, 0x8c, - 0xb1, 0xfe, 0xaf, 0x05, 0xc5, 0xd6, 0x84, 0xb9, 0xd7, 0x2f, 0x28, 0xf1, 0x68, 0x8c, 0x2a, 0xb0, - 0x7d, 0x43, 0x63, 0xee, 0xb3, 0xb0, 0x62, 0x1d, 0x5a, 0x47, 0x59, 0x9c, 0xaa, 0x08, 0x41, 0x76, - 0x4c, 0xf8, 0xb8, 0xb2, 0x79, 0x68, 0x1d, 0x15, 0xb0, 0x92, 0xd1, 0x2e, 0xe4, 0xc6, 0xd4, 0x1f, - 0x8d, 0x45, 0x25, 0xa3, 0x9c, 0x8d, 0x86, 0x1a, 0xf0, 0x49, 0x14, 0xd3, 0x1b, 0x9f, 0x25, 0xdc, - 0x76, 0xe4, 0xed, 0xb6, 0x3a, 0x9a, 0x55, 0x47, 0xef, 0xa5, 0x26, 0x1d, 0x57, 0xde, 0x73, 0x00, - 0xc5, 0x80, 0xc6, 0xd7, 0x13, 0x6a, 0xc7, 0x8c, 0x89, 0xca, 0x96, 0xf2, 0x03, 0x0d, 0x61, 0xc6, - 0x04, 0xba, 0x0f, 0x5b, 0x21, 0x0b, 0x5d, 0x5a, 0xc9, 0xa9, 0x38, 0x5a, 0x91, 0x29, 0x39, 0xbe, - 0xe0, 0x95, 0x6d, 0x9d, 0x92, 0x94, 0x25, 0x26, 0x7b, 0x57, 0xc9, 0x2b, 0x47, 0x25, 0xa3, 0x32, - 0x64, 0x42, 0x31, 0xad, 0x14, 0x14, 0x24, 0xc5, 0xfa, 0xaf, 0x16, 0x94, 0x06, 0xfe, 0x28, 0xf4, - 0xc3, 0x11, 0xa6, 0xaf, 0x13, 0xca, 0x85, 0xac, 0x9c, 0x78, 0x5e, 0x4c, 0x39, 0x57, 0x95, 0x17, - 0x70, 0xaa, 0xa2, 0x2a, 0xe4, 0xb9, 0x74, 0x92, 0xf1, 0x37, 0xd5, 0x1d, 0x33, 0x5d, 0x85, 0x9b, - 0xfa, 0x9e, 0xaa, 0xbf, 0x80, 0x95, 0x2c, 0xb1, 0x88, 0x3b, 0xc2, 0x94, 0xab, 0x64, 0xf4, 0x0c, - 0x72, 0x5c, 0x10, 0x91, 0x70, 0x55, 0x5c, 0xe9, 0xf8, 0x51, 0x63, 0x99, 0x32, 0x0d, 0x93, 0xcd, - 0x40, 0x39, 0x61, 0xe3, 0x5c, 0xff, 0xc7, 0x82, 0xec, 0xe5, 0xf0, 0x87, 0xf3, 0x59, 0x1c, 0x6b, - 0x39, 0xce, 0x0d, 0x4b, 0x84, 0xc9, 0x49, 0xc9, 0x8b, 0x55, 0x64, 0x96, 0xab, 0xd8, 0x85, 0x1c, - 0x09, 0x58, 0x12, 0xea, 0xbc, 0xb2, 0xd8, 0x68, 0x0b, 0x33, 0xdc, 0x5a, 0x9a, 0xe1, 0x67, 0x50, - 0x8a, 0x12, 0xc7, 0xbe, 0xa6, 0xb7, 0x36, 0x77, 0x63, 0x3f, 0x12, 0xaa, 0xf7, 0x77, 0xf0, 0x9d, - 0x28, 0x71, 0xce, 0xe8, 0xed, 0x40, 0x61, 0x68, 0x1f, 0x0a, 0x3e, 0xb7, 0xe5, 0x20, 0xa9, 0xa7, - 0xe6, 0x90, 0xc7, 0x79, 0x9f, 0xbf, 0x54, 0x3a, 0x7a, 0x0a, 0x5b, 0x71, 0x12, 0x52, 0x5e, 0xc9, - 0x1f, 0x66, 0x8e, 0x8a, 0xc7, 0xfb, 0xab, 0x35, 0xe3, 0x24, 0xa4, 0x2d, 0x32, 0x21, 0xa1, 0x4b, - 0xb1, 0xf6, 0xac, 0x3f, 0x83, 0xe2, 0x02, 0x8a, 0x4a, 0xb0, 0x39, 0x2b, 0x7a, 0xd3, 0xf7, 0x16, - 0x8a, 0xd0, 0x34, 0x34, 0x5a, 0xbd, 0x01, 0x39, 0x79, 0xac, 0xe7, 0x49, 0xa6, 0x28, 0xc6, 0x19, - 0xfa, 0x6a, 0x45, 0xde, 0x23, 0xa6, 0xea, 0xcc, 0x0e, 0xde, 0x14, 0xd3, 0xba, 0x0d, 0x5b, 0x1d, - 0xcf, 0x77, 0x05, 0x7a, 0x3c, 0x0b, 0x50, 0x3c, 0xde, 0x5d, 0x97, 0x5f, 0xcf, 0xfb, 0x58, 0x60, - 0x89, 0xb3, 0x44, 0x44, 0x89, 0xde, 0x80, 0x1d, 0x6c, 0xb4, 0xfa, 0xf7, 0x50, 0x6e, 0x09, 0xf7, - 0x94, 0x85, 0x9c, 0x4d, 0x7c, 0x8f, 0x08, 0xb9, 0x41, 0x5f, 0x42, 0x59, 0x90, 0x78, 0x44, 0x85, - 0x2d, 0xc6, 0x31, 0xe5, 0x63, 0x36, 0xd1, 0x91, 0x33, 0xf8, 0xae, 0xc6, 0x87, 0x29, 0x8c, 0x1e, - 0xc0, 0x76, 0x40, 0xa6, 0x76, 0x98, 0x04, 0x26, 0xe9, 0x5c, 0x40, 0xa6, 0xfd, 0x24, 0xa8, 0xbf, - 0x06, 0x24, 0xb3, 0xe2, 0xcb, 0x37, 0x3f, 0x80, 0x6d, 0xd9, 0x3e, 0x7b, 0xd6, 0xab, 0x5c, 0xac, - 0xbb, 0xb1, 0x2e, 0xa4, 0x2e, 0xe0, 0x63, 0x21, 0x33, 0x4b, 0x21, 0x7f, 0xb2, 0xa0, 0xd4, 0x3e, - 0xeb, 0x5e, 0x90, 0x58, 0xf8, 0xae, 0x1f, 0x91, 0x50, 0xb1, 0x2c, 0x60, 0xa1, 0x7f, 0x4d, 0xe3, - 0x74, 0x57, 0x8c, 0x2a, 0x03, 0xb2, 0x88, 0xc6, 0x44, 0xb0, 0xd8, 0x4e, 0x89, 0x68, 0x02, 0xa6, - 0xf8, 0x89, 0x21, 0xe4, 0x57, 0x70, 0xcf, 0x65, 0x21, 0xa7, 0x21, 0x4f, 0xb8, 0xbd, 0x4c, 0xda, - 0xf2, 0xcc, 0x60, 0x9c, 0xeb, 0xbf, 0x67, 0x00, 0xda, 0x67, 0xdd, 0x74, 0x59, 0xe7, 0xbc, 0xc8, - 0xaa, 0xf1, 0xb4, 0xe0, 0x4e, 0x34, 0xcf, 0x4f, 0x86, 0x94, 0x84, 0xab, 0xad, 0x0e, 0x74, 0xb9, - 0x0c, 0xbc, 0x74, 0x06, 0x3d, 0x84, 0xc2, 0xbc, 0x49, 0xba, 0x05, 0x73, 0x00, 0x7d, 0x0b, 0xc5, - 0x1b, 0x92, 0x4c, 0x84, 0x2d, 0x6e, 0x23, 0xca, 0x2b, 0xd9, 0xc3, 0xcc, 0x51, 0xe9, 0x78, 0x6f, - 0x35, 0xc0, 0x09, 0xe7, 0x54, 0x0c, 0x6f, 0x23, 0x8a, 0x41, 0x79, 0x4b, 0x91, 0xa3, 0xcf, 0xa1, - 0xe4, 0xf9, 0x9c, 0x38, 0x13, 0x6a, 0x6b, 0x3f, 0xb5, 0x6a, 0x79, 0xbc, 0x63, 0xd0, 0x96, 0x02, - 0xd1, 0x17, 0x70, 0x97, 0x86, 0xca, 0x4b, 0xc4, 0x24, 0xe4, 0x57, 0x34, 0x56, 0x2b, 0x97, 0xc7, - 0x25, 0x0d, 0x0f, 0x0d, 0x8a, 0x1e, 0x83, 0x99, 0x9e, 0x9d, 0x88, 0x29, 0x53, 0x23, 0xdb, 0x56, - 0xf9, 0xee, 0x68, 0xf8, 0x52, 0x4c, 0x59, 0x3f, 0x09, 0xd0, 0x1e, 0xe4, 0xaf, 0x28, 0xb5, 0x63, - 0x22, 0xf4, 0x7b, 0x58, 0xc0, 0xdb, 0x57, 0x94, 0x62, 0x22, 0x28, 0x6a, 0x03, 0xd0, 0x69, 0xe4, - 0xc7, 0x8a, 0x3f, 0xea, 0x65, 0x2c, 0x1e, 0x57, 0x1b, 0xfa, 0x2b, 0xd4, 0x48, 0xbf, 0x42, 0x8d, - 0x61, 0xfa, 0x15, 0x6a, 0xe5, 0xdf, 0xfe, 0x79, 0x60, 0xbd, 0xf9, 0xeb, 0xc0, 0xc2, 0x0b, 0xe7, - 0xd0, 0x37, 0xb3, 0x57, 0x0d, 0xd4, 0xab, 0x76, 0xb8, 0xa6, 0xe1, 0x66, 0x64, 0x2b, 0x0f, 0xdb, - 0xcf, 0x16, 0xdc, 0x6f, 0x9f, 0x75, 0x4f, 0x59, 0x10, 0x4d, 0xa8, 0xbc, 0xeb, 0xff, 0x26, 0xbb, - 0x0b, 0x39, 0x4e, 0x43, 0x8f, 0xc6, 0xe9, 0xe2, 0x69, 0x4d, 0xe2, 0xaa, 0xc3, 0x92, 0x32, 0x19, - 0x89, 0x6b, 0x6d, 0x3d, 0xab, 0xb2, 0xeb, 0x59, 0x25, 0x47, 0xce, 0xfd, 0x51, 0x48, 0x44, 0x12, - 0x53, 0xf3, 0xd5, 0x99, 0x03, 0x4f, 0x7e, 0xb1, 0x60, 0x67, 0xe9, 0x59, 0x46, 0x35, 0xa8, 0x0e, - 0x7a, 0xdd, 0x7e, 0xaf, 0xdf, 0xb5, 0x07, 0xc3, 0x93, 0xe1, 0xe5, 0xc0, 0xbe, 0xec, 0x0f, 0x2e, - 0x3a, 0xa7, 0xbd, 0xe7, 0xbd, 0x4e, 0xbb, 0xbc, 0x81, 0xaa, 0xb0, 0xbb, 0x62, 0xbf, 0xe8, 0xf4, - 0xdb, 0xbd, 0x7e, 0xb7, 0x6c, 0xad, 0x39, 0xdb, 0xc2, 0xe7, 0x27, 0xed, 0xd3, 0x93, 0xc1, 0xb0, - 0xd3, 0x2e, 0x6f, 0xa2, 0x87, 0x50, 0x59, 0xb1, 0x9f, 0x9e, 0xf7, 0x9f, 0xf7, 0xf0, 0xab, 0x4e, - 0xbb, 0x9c, 0x41, 0x7b, 0xf0, 0xe9, 0x8a, 0xf5, 0xf9, 0x49, 0xef, 0x65, 0xa7, 0x5d, 0xce, 0x3e, - 0xf9, 0xcd, 0x82, 0xf2, 0x6a, 0x9f, 0x51, 0x1d, 0x6a, 0xed, 0xb3, 0xae, 0x8d, 0x3b, 0xdf, 0x5d, - 0x76, 0x06, 0xc3, 0xf5, 0xd9, 0xd6, 0xa0, 0xba, 0xc6, 0x67, 0x9e, 0xf1, 0x21, 0x3c, 0x5c, 0x63, - 0x3f, 0x3d, 0x7f, 0x75, 0xf1, 0xb2, 0xa3, 0x73, 0x7e, 0x04, 0x7b, 0x6b, 0x3c, 0x4c, 0x66, 0x19, - 0x74, 0x00, 0xfb, 0x6b, 0xcc, 0xc3, 0xde, 0xab, 0x4e, 0xfb, 0xfc, 0x72, 0x58, 0xce, 0xb6, 0x5e, - 0xbc, 0x7d, 0x5f, 0xb3, 0xde, 0xbd, 0xaf, 0x59, 0x7f, 0xbf, 0xaf, 0x59, 0x6f, 0x3e, 0xd4, 0x36, - 0xde, 0x7d, 0xa8, 0x6d, 0xfc, 0xf1, 0xa1, 0xb6, 0xf1, 0x63, 0x63, 0xe4, 0x8b, 0x71, 0xe2, 0x34, - 0x5c, 0x16, 0x34, 0x25, 0xa7, 0x14, 0x25, 0x5d, 0x36, 0x51, 0x4a, 0x73, 0xba, 0xf0, 0x3b, 0xa3, - 0xf6, 0xd1, 0xc9, 0x29, 0x87, 0xaf, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x7f, 0x2e, 0x6f, 0x82, - 0xaa, 0x09, 0x00, 0x00, + // 1229 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x56, 0x4f, 0x6f, 0x1a, 0x47, + 0x14, 0xf7, 0x1a, 0x8c, 0xe1, 0x11, 0x13, 0x32, 0x4d, 0x1d, 0x8c, 0x13, 0x6c, 0xa1, 0x36, 0x75, + 0x53, 0x09, 0x14, 0x57, 0x91, 0xaa, 0xde, 0x8c, 0x21, 0x04, 0x39, 0xc1, 0xee, 0x02, 0x6d, 0xd5, + 0xcb, 0x6a, 0x76, 0x77, 0x0c, 0x2b, 0xb3, 0x3b, 0x9b, 0x99, 0x59, 0x17, 0x5f, 0xfb, 0x09, 0xf2, + 0x15, 0x2a, 0xb5, 0xdf, 0xa1, 0x1f, 0x21, 0x97, 0x4a, 0x39, 0xf6, 0xd4, 0x56, 0xf1, 0xbd, 0xa7, + 0x7e, 0x80, 0x6a, 0xfe, 0x00, 0x06, 0xe1, 0xf4, 0xf6, 0xde, 0xef, 0xbd, 0x99, 0xf7, 0x9b, 0xf7, + 0x7e, 0xb3, 0xb3, 0x50, 0xe1, 0x81, 0x4f, 0xea, 0xae, 0xf0, 0x5c, 0x16, 0xf8, 0xc3, 0x1b, 0x56, + 0x2d, 0x66, 0x54, 0x50, 0x54, 0x90, 0xf1, 0xda, 0x0c, 0x2d, 0xdf, 0x1f, 0xd2, 0x21, 0x55, 0xa1, + 0xba, 0xb4, 0x74, 0x56, 0x79, 0x67, 0x48, 0xe9, 0x70, 0x4c, 0xea, 0xca, 0x73, 0x93, 0xf3, 0x3a, + 0x8e, 0xae, 0x4c, 0x68, 0x6f, 0x39, 0x24, 0x82, 0x90, 0x70, 0x81, 0xc3, 0xd8, 0x24, 0x54, 0x3c, + 0xca, 0x43, 0xca, 0xeb, 0x2e, 0xe6, 0xa4, 0x7e, 0xf9, 0xd4, 0x25, 0x02, 0x3f, 0xad, 0x7b, 0x34, + 0x88, 0xa6, 0x7b, 0xeb, 0xb8, 0xa3, 0x8b, 0x6a, 0xc7, 0x84, 0x76, 0x97, 0xc8, 0xc7, 0x98, 0xe1, + 0xd0, 0x04, 0xab, 0xff, 0x5a, 0x90, 0x6f, 0x8c, 0xa9, 0x77, 0xf1, 0x82, 0x60, 0x9f, 0x30, 0x54, + 0x82, 0xcd, 0x4b, 0xc2, 0x78, 0x40, 0xa3, 0x92, 0xb5, 0x6f, 0x1d, 0xa4, 0xed, 0xa9, 0x8b, 0x10, + 0xa4, 0x47, 0x98, 0x8f, 0x4a, 0xeb, 0xfb, 0xd6, 0x41, 0xce, 0x56, 0x36, 0xda, 0x86, 0xcc, 0x88, + 0x04, 0xc3, 0x91, 0x28, 0xa5, 0x54, 0xb2, 0xf1, 0x50, 0x0d, 0x3e, 0x8a, 0x19, 0xb9, 0x0c, 0x68, + 0xc2, 0x1d, 0x57, 0xee, 0xee, 0xa8, 0xa5, 0x69, 0xb5, 0xf4, 0xde, 0x34, 0xa4, 0xeb, 0xca, 0x7d, + 0xf6, 0x20, 0x1f, 0x12, 0x76, 0x31, 0x26, 0x0e, 0xa3, 0x54, 0x94, 0x36, 0x54, 0x1e, 0x68, 0xc8, + 0xa6, 0x54, 0xa0, 0xfb, 0xb0, 0x11, 0xd1, 0xc8, 0x23, 0xa5, 0x8c, 0xaa, 0xa3, 0x1d, 0x49, 0xc9, + 0x0d, 0x04, 0x2f, 0x6d, 0x6a, 0x4a, 0xd2, 0x96, 0x98, 0xec, 0x5d, 0x29, 0xab, 0x12, 0x95, 0x8d, + 0x8a, 0x90, 0x8a, 0xc4, 0xa4, 0x94, 0x53, 0x90, 0x34, 0xab, 0xbf, 0x5a, 0x50, 0xe8, 0x05, 0xc3, + 0x28, 0x88, 0x86, 0x36, 0x79, 0x9d, 0x10, 0x2e, 0xe4, 0xc9, 0xb1, 0xef, 0x33, 0xc2, 0xb9, 0x3a, + 0x79, 0xce, 0x9e, 0xba, 0xa8, 0x0c, 0x59, 0x2e, 0x93, 0x64, 0xfd, 0x75, 0xb5, 0xc7, 0xcc, 0x57, + 0xe5, 0x26, 0x81, 0xaf, 0xce, 0x9f, 0xb3, 0x95, 0x2d, 0xb1, 0x98, 0xbb, 0xc2, 0x1c, 0x57, 0xd9, + 0xe8, 0x19, 0x64, 0xb8, 0xc0, 0x22, 0xe1, 0xea, 0x70, 0x85, 0xc3, 0x47, 0xb5, 0x45, 0xc9, 0xd4, + 0x0c, 0x9b, 0x9e, 0x4a, 0xb2, 0x4d, 0x72, 0x95, 0xc3, 0xdd, 0xef, 0x02, 0x31, 0xf2, 0x19, 0xfe, + 0xf1, 0xff, 0x79, 0x6e, 0x43, 0x06, 0x87, 0x34, 0x89, 0x84, 0x99, 0x91, 0xf1, 0x16, 0xf8, 0xa7, + 0x6e, 0xe1, 0x9f, 0x9e, 0xf3, 0xaf, 0xfe, 0x63, 0x41, 0x7a, 0xd0, 0xff, 0xfe, 0x74, 0x16, 0xb4, + 0x16, 0x0f, 0x77, 0x49, 0x13, 0x61, 0x1a, 0xa1, 0xec, 0x9b, 0x94, 0x52, 0xb7, 0x51, 0x4a, 0x6b, + 0x81, 0x18, 0x4a, 0x73, 0xe1, 0x6c, 0x2c, 0x08, 0xe7, 0x13, 0x28, 0xc4, 0x89, 0xeb, 0x5c, 0x90, + 0x2b, 0x87, 0x7b, 0x2c, 0x88, 0x85, 0x1a, 0xf8, 0x1d, 0xfb, 0x4e, 0x9c, 0xb8, 0x27, 0xe4, 0xaa, + 0xa7, 0x30, 0xb4, 0x0b, 0xb9, 0x80, 0x3b, 0x52, 0x3d, 0xc4, 0x57, 0xc3, 0xcf, 0xda, 0xd9, 0x80, + 0xbf, 0x54, 0x3e, 0x7a, 0x0a, 0x1b, 0x2c, 0x89, 0x08, 0x2f, 0x65, 0xf7, 0x53, 0x07, 0xf9, 0xc3, + 0xdd, 0xe5, 0x46, 0xdb, 0x49, 0x44, 0x1a, 0x78, 0x8c, 0x23, 0x8f, 0xd8, 0x3a, 0xb3, 0xfa, 0x0c, + 0xf2, 0x37, 0x50, 0x54, 0x80, 0xf5, 0xd9, 0xa1, 0xd7, 0x03, 0xff, 0xb6, 0xbe, 0x56, 0x6b, 0x90, + 0x91, 0xcb, 0x3a, 0xbe, 0x94, 0xa7, 0x92, 0xb9, 0xb9, 0x33, 0xda, 0x91, 0xfb, 0x88, 0x89, 0x5a, + 0xb3, 0x65, 0xaf, 0x8b, 0x49, 0xd5, 0x81, 0x8d, 0x96, 0x1f, 0x78, 0x02, 0x3d, 0x9e, 0x15, 0xc8, + 0x1f, 0x6e, 0xaf, 0xe2, 0xd7, 0xf1, 0x3f, 0x54, 0x58, 0xe2, 0x34, 0x11, 0x71, 0xa2, 0xaf, 0xdd, + 0x96, 0x6d, 0xbc, 0xea, 0xb7, 0x50, 0x6c, 0x08, 0xef, 0x98, 0x46, 0x9c, 0x8e, 0x03, 0x1f, 0x0b, + 0x79, 0x6d, 0x3f, 0x87, 0xa2, 0xc0, 0x6c, 0x48, 0x84, 0x23, 0x46, 0x8c, 0xf0, 0x11, 0x1d, 0xeb, + 0xca, 0x29, 0xfb, 0xae, 0xc6, 0xfb, 0x53, 0x18, 0x3d, 0x80, 0xcd, 0x10, 0x4f, 0x9c, 0x28, 0x09, + 0x0d, 0xe9, 0x4c, 0x88, 0x27, 0xdd, 0x24, 0xac, 0xbe, 0x06, 0x24, 0x59, 0xf1, 0xc5, 0x9d, 0x1f, + 0xc0, 0xa6, 0x6c, 0x9f, 0x33, 0xeb, 0x55, 0x86, 0xe9, 0x6e, 0xac, 0x2a, 0xa9, 0x0f, 0xf0, 0xa1, + 0x92, 0xa9, 0x85, 0x92, 0x3f, 0x59, 0x50, 0x68, 0x9e, 0xb4, 0xcf, 0x30, 0x13, 0x81, 0x17, 0xc4, + 0x38, 0x52, 0x2a, 0x0b, 0x69, 0x14, 0x5c, 0x10, 0x36, 0x15, 0xbe, 0x71, 0x65, 0x41, 0x1a, 0x13, + 0x86, 0x05, 0x65, 0xce, 0x54, 0x88, 0xa6, 0xe0, 0x14, 0x3f, 0x32, 0x82, 0xfc, 0x02, 0xee, 0x79, + 0x34, 0xe2, 0x24, 0xe2, 0x09, 0x77, 0x16, 0x45, 0x5b, 0x9c, 0x05, 0x4c, 0x72, 0xf5, 0xf7, 0x14, + 0x40, 0xf3, 0xa4, 0x3d, 0xbd, 0x79, 0x73, 0x5d, 0xa4, 0xd5, 0x78, 0x1a, 0x70, 0x27, 0x9e, 0xf3, + 0x93, 0x25, 0xa5, 0xe0, 0x2a, 0xcb, 0x03, 0x5d, 0x3c, 0x86, 0xbd, 0xb0, 0x06, 0x3d, 0x84, 0xdc, + 0xbc, 0x49, 0xba, 0x05, 0x73, 0x00, 0x7d, 0x0d, 0xf9, 0x4b, 0x9c, 0x8c, 0x85, 0x23, 0xae, 0x62, + 0xc2, 0x4b, 0xe9, 0xfd, 0xd4, 0x41, 0xe1, 0x70, 0x67, 0xb9, 0xc0, 0x11, 0xe7, 0x44, 0xf4, 0xaf, + 0x62, 0x62, 0x83, 0xca, 0x96, 0x26, 0x47, 0x9f, 0x42, 0xc1, 0x0f, 0x38, 0x76, 0xc7, 0xc4, 0xd1, + 0x79, 0xea, 0xaa, 0x65, 0xed, 0x2d, 0x83, 0x36, 0x14, 0x88, 0x3e, 0x83, 0xbb, 0x24, 0x52, 0x59, + 0x82, 0xe1, 0x88, 0x9f, 0x13, 0xa6, 0xae, 0x5c, 0xd6, 0x2e, 0x68, 0xb8, 0x6f, 0x50, 0xf4, 0x18, + 0xcc, 0xf4, 0x9c, 0x44, 0x4c, 0xa8, 0x1a, 0xd9, 0xa6, 0xe2, 0xbb, 0xa5, 0xe1, 0x81, 0x98, 0xd0, + 0x6e, 0x12, 0xa2, 0x1d, 0xc8, 0x9e, 0x13, 0xe2, 0x30, 0x2c, 0xf4, 0x47, 0x38, 0x67, 0x6f, 0x9e, + 0x13, 0x62, 0x63, 0x41, 0x50, 0x13, 0x80, 0x4c, 0xe2, 0x80, 0x29, 0xfd, 0xa8, 0xcf, 0x71, 0xfe, + 0xb0, 0x5c, 0xd3, 0x4f, 0x5f, 0x6d, 0xfa, 0xf4, 0xd5, 0xfa, 0xd3, 0xa7, 0xaf, 0x91, 0x7d, 0xfb, + 0xe7, 0x9e, 0xf5, 0xe6, 0xaf, 0x3d, 0xcb, 0xbe, 0xb1, 0x0e, 0x7d, 0x35, 0xfb, 0x94, 0x82, 0xfa, + 0x94, 0xee, 0xaf, 0x68, 0xb8, 0x19, 0xd9, 0xd2, 0xd7, 0xf4, 0x67, 0x0b, 0xee, 0x37, 0x4f, 0xda, + 0xc7, 0x34, 0x8c, 0xc7, 0x44, 0xee, 0x75, 0xdb, 0x64, 0xb7, 0x21, 0xc3, 0x49, 0xe4, 0x13, 0x36, + 0xbd, 0x78, 0xda, 0x93, 0xb8, 0xea, 0xb0, 0x94, 0x4c, 0x4a, 0xe2, 0xda, 0x5b, 0xad, 0xaa, 0xf4, + 0x6a, 0x55, 0xc9, 0x91, 0xf3, 0x60, 0x18, 0x61, 0x91, 0x30, 0x62, 0x9e, 0xba, 0x39, 0xf0, 0xe4, + 0x17, 0x0b, 0xb6, 0x16, 0xde, 0x02, 0x54, 0x81, 0x72, 0xaf, 0xd3, 0xee, 0x76, 0xba, 0x6d, 0xa7, + 0xd7, 0x3f, 0xea, 0x0f, 0x7a, 0xce, 0xa0, 0xdb, 0x3b, 0x6b, 0x1d, 0x77, 0x9e, 0x77, 0x5a, 0xcd, + 0xe2, 0x1a, 0x2a, 0xc3, 0xf6, 0x52, 0xfc, 0xac, 0xd5, 0x6d, 0x76, 0xba, 0xed, 0xa2, 0xb5, 0x62, + 0x6d, 0xc3, 0x3e, 0x3d, 0x6a, 0x1e, 0x1f, 0xf5, 0xfa, 0xad, 0x66, 0x71, 0x1d, 0x3d, 0x84, 0xd2, + 0x52, 0xfc, 0xf8, 0xb4, 0xfb, 0xbc, 0x63, 0xbf, 0x6a, 0x35, 0x8b, 0x29, 0xb4, 0x03, 0x1f, 0x2f, + 0x45, 0x9f, 0x1f, 0x75, 0x5e, 0xb6, 0x9a, 0xc5, 0xf4, 0x93, 0xdf, 0x2c, 0x28, 0x2e, 0xf7, 0x19, + 0x55, 0xa1, 0xd2, 0x3c, 0x69, 0x3b, 0x76, 0xeb, 0x9b, 0x41, 0xab, 0xd7, 0x5f, 0xcd, 0xb6, 0x02, + 0xe5, 0x15, 0x39, 0x73, 0xc6, 0xfb, 0xf0, 0x70, 0x45, 0xfc, 0xf8, 0xf4, 0xd5, 0xd9, 0xcb, 0x96, + 0xe6, 0xfc, 0x08, 0x76, 0x56, 0x64, 0x18, 0x66, 0x29, 0xb4, 0x07, 0xbb, 0x2b, 0xc2, 0xfd, 0xce, + 0xab, 0x56, 0xf3, 0x74, 0xd0, 0x2f, 0xa6, 0x1b, 0x2f, 0xde, 0xbe, 0xaf, 0x58, 0xef, 0xde, 0x57, + 0xac, 0xbf, 0xdf, 0x57, 0xac, 0x37, 0xd7, 0x95, 0xb5, 0x77, 0xd7, 0x95, 0xb5, 0x3f, 0xae, 0x2b, + 0x6b, 0x3f, 0xd4, 0x86, 0x81, 0x18, 0x25, 0x6e, 0xcd, 0xa3, 0x61, 0x5d, 0x6a, 0x4a, 0x49, 0xd2, + 0xa3, 0x63, 0xe5, 0xd4, 0x27, 0x37, 0xfe, 0xa1, 0xd4, 0x7d, 0x74, 0x33, 0x2a, 0xe1, 0xcb, 0xff, + 0x02, 0x00, 0x00, 0xff, 0xff, 0xea, 0x4a, 0x24, 0x24, 0x1f, 0x0a, 0x00, 0x00, } func (m *BlockHeader) Marshal() (dAtA []byte, err error) { @@ -1188,6 +1259,55 @@ func (m *SigningRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *WithdrawRequest) 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 *WithdrawRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WithdrawRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Txid) > 0 { + i -= len(m.Txid) + copy(dAtA[i:], m.Txid) + i = encodeVarintBtcbridge(dAtA, i, uint64(len(m.Txid))) + i-- + dAtA[i] = 0x22 + } + if m.Sequence != 0 { + i = encodeVarintBtcbridge(dAtA, i, uint64(m.Sequence)) + i-- + dAtA[i] = 0x18 + } + if len(m.Amount) > 0 { + i -= len(m.Amount) + copy(dAtA[i:], m.Amount) + i = encodeVarintBtcbridge(dAtA, i, uint64(len(m.Amount))) + i-- + dAtA[i] = 0x12 + } + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintBtcbridge(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *UTXO) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1755,6 +1875,30 @@ func (m *SigningRequest) Size() (n int) { return n } +func (m *WithdrawRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + if l > 0 { + n += 1 + l + sovBtcbridge(uint64(l)) + } + l = len(m.Amount) + if l > 0 { + n += 1 + l + sovBtcbridge(uint64(l)) + } + if m.Sequence != 0 { + n += 1 + sovBtcbridge(uint64(m.Sequence)) + } + l = len(m.Txid) + if l > 0 { + n += 1 + l + sovBtcbridge(uint64(l)) + } + return n +} + func (m *UTXO) Size() (n int) { if m == nil { return 0 @@ -2443,6 +2587,171 @@ func (m *SigningRequest) Unmarshal(dAtA []byte) error { } return nil } +func (m *WithdrawRequest) 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 ErrIntOverflowBtcbridge + } + 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: WithdrawRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WithdrawRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBtcbridge + } + 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 ErrInvalidLengthBtcbridge + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBtcbridge + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBtcbridge + } + 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 ErrInvalidLengthBtcbridge + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBtcbridge + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Amount = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType) + } + m.Sequence = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBtcbridge + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Sequence |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Txid", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBtcbridge + } + 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 ErrInvalidLengthBtcbridge + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBtcbridge + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Txid = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipBtcbridge(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBtcbridge + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *UTXO) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/x/btcbridge/types/errors.go b/x/btcbridge/types/errors.go index e60bf951..1e9d790a 100644 --- a/x/btcbridge/types/errors.go +++ b/x/btcbridge/types/errors.go @@ -24,6 +24,7 @@ var ( ErrInvalidDepositAmount = errorsmod.Register(ModuleName, 2109, "invalid deposit amount") ErrDepositNotEnabled = errorsmod.Register(ModuleName, 2110, "deposit not enabled") ErrUntrustedNonBtcRelayer = errorsmod.Register(ModuleName, 2111, "untrusted non btc relayer") + ErruntrustedOracle = errorsmod.Register(ModuleName, 2112, "untrusted oracle") ErrInvalidAmount = errorsmod.Register(ModuleName, 3100, "invalid amount") ErrInvalidFeeRate = errorsmod.Register(ModuleName, 3101, "invalid fee rate") @@ -32,11 +33,12 @@ var ( ErrDustOutput = errorsmod.Register(ModuleName, 3104, "too small output amount") ErrInsufficientUTXOs = errorsmod.Register(ModuleName, 3105, "insufficient utxos") ErrMaxTransactionWeightExceeded = errorsmod.Register(ModuleName, 3106, "maximum transaction weight exceeded") - ErrFailToSerializePsbt = errorsmod.Register(ModuleName, 3107, "failed to serialize psbt") - ErrInvalidSignatures = errorsmod.Register(ModuleName, 3108, "invalid signatures") - ErrSigningRequestNotExist = errorsmod.Register(ModuleName, 3109, "signing request does not exist") - ErrSigningRequestConfirmed = errorsmod.Register(ModuleName, 3110, "signing request has been confirmed") - ErrWithdrawNotEnabled = errorsmod.Register(ModuleName, 3111, "withdrawal not enabled") + ErrMaxUTXONumExceeded = errorsmod.Register(ModuleName, 3107, "maximum utxo number exceeded") + ErrFailToSerializePsbt = errorsmod.Register(ModuleName, 3108, "failed to serialize psbt") + ErrInvalidSignatures = errorsmod.Register(ModuleName, 3109, "invalid signatures") + ErrSigningRequestNotExist = errorsmod.Register(ModuleName, 3110, "signing request does not exist") + ErrSigningRequestConfirmed = errorsmod.Register(ModuleName, 3111, "signing request has been confirmed") + ErrWithdrawNotEnabled = errorsmod.Register(ModuleName, 3112, "withdrawal not enabled") ErrUTXODoesNotExist = errorsmod.Register(ModuleName, 4100, "utxo does not exist") ErrUTXOLocked = errorsmod.Register(ModuleName, 4101, "utxo locked") @@ -47,6 +49,7 @@ var ( ErrInvalidParams = errorsmod.Register(ModuleName, 6100, "invalid module params") ErrInvalidRelayers = errorsmod.Register(ModuleName, 6101, "invalid relayers") + ErrInvalidOracles = errorsmod.Register(ModuleName, 6102, "invalid oracles") ErrInvalidDKGParams = errorsmod.Register(ModuleName, 7100, "invalid dkg params") ErrDKGRequestDoesNotExist = errorsmod.Register(ModuleName, 7101, "dkg request does not exist") diff --git a/x/btcbridge/types/keys.go b/x/btcbridge/types/keys.go index cd61cf9a..5b458e4e 100644 --- a/x/btcbridge/types/keys.go +++ b/x/btcbridge/types/keys.go @@ -20,25 +20,30 @@ const ( var ( ParamsStoreKey = []byte{0x1} - SequenceKey = []byte{0x2} - - // Host chain keys prefix the HostChain structs - BtcBlockHeaderHashPrefix = []byte{0x11} // prefix for each key to a block header, for a hash - BtcBlockHeaderHeightPrefix = []byte{0x12} // prefix for each key to a block hash, for a height - BtcBestBlockHeaderKey = []byte{0x13} // key for the best block height - BtcSigningRequestPrefix = []byte{0x14} // prefix for each key to a signing request - BtcSigningRequestByTxHashPrefix = []byte{0x15} // prefix for each key to a signing request from tx hash - BtcMintedTxHashKeyPrefix = []byte{0x16} // prefix for each key to a minted tx hash - BtcLockedAssetKeyPrefix = []byte{0x17} // prefix for each key to the locked asset - - BtcUtxoKeyPrefix = []byte{0x20} // prefix for each key to a utxo - BtcOwnerUtxoKeyPrefix = []byte{0x21} // prefix for each key to an owned utxo - BtcOwnerRunesUtxoKeyPrefix = []byte{0x22} // prefix for each key to an owned runes utxo - - DKGRequestIDKey = []byte{0x30} // key for the DKG request id - DKGRequestKeyPrefix = []byte{0x31} // prefix for each key to a DKG request - DKGCompletionRequestKeyPrefix = []byte{0x32} // prefix for each key to a DKG completion request - VaultVersionKey = []byte{0x33} // key for vault version increased by 1 once updated + + BtcBlockHeaderHashPrefix = []byte{0x10} // prefix for each key to a block header, for a hash + BtcBlockHeaderHeightPrefix = []byte{0x11} // prefix for each key to a block hash, for a height + BtcBestBlockHeaderKey = []byte{0x12} // key for the best block height + BtcFeeRateKey = []byte{0x13} // key for the bitcoin network fee rate + + BtcWithdrawRequestSequenceKey = []byte{0x20} // key for the withdrawal request sequence + BtcWithdrawRequestKeyPrefix = []byte{0x21} // prefix for each key to a withdrawal request + BtcWithdrawRequestByTxHashKeyPrefix = []byte{0x22} // prefix for each key to a withdrawal request by tx hash + BtcWithdrawRequestQueueKeyPrefix = []byte{0x23} // prefix for each key to a pending btc withdrawal request + BtcSigningRequestSequenceKey = []byte{0x24} // key for the signing request sequence + BtcSigningRequestPrefix = []byte{0x25} // prefix for each key to a signing request + BtcSigningRequestByTxHashPrefix = []byte{0x26} // prefix for each key to a signing request from tx hash + BtcMintedTxHashKeyPrefix = []byte{0x27} // prefix for each key to a minted tx hash + + BtcUtxoKeyPrefix = []byte{0x30} // prefix for each key to a utxo + BtcOwnerUtxoKeyPrefix = []byte{0x31} // prefix for each key to an owned utxo + BtcOwnerUtxoByAmountKeyPrefix = []byte{0x32} // prefix for each key to an owned utxo by amount + BtcOwnerRunesUtxoKeyPrefix = []byte{0x33} // prefix for each key to an owned runes utxo + + DKGRequestIDKey = []byte{0x40} // key for the DKG request id + DKGRequestKeyPrefix = []byte{0x41} // prefix for each key to a DKG request + DKGCompletionRequestKeyPrefix = []byte{0x42} // prefix for each key to a DKG completion request + VaultVersionKey = []byte{0x43} // key for vault version increased by 1 once updated ) func BtcBlockHeaderHashKey(hash string) []byte { @@ -49,6 +54,18 @@ func BtcBlockHeaderHeightKey(height uint64) []byte { return append(BtcBlockHeaderHeightPrefix, sdk.Uint64ToBigEndian(height)...) } +func BtcWithdrawRequestKey(sequence uint64) []byte { + return append(BtcWithdrawRequestKeyPrefix, sdk.Uint64ToBigEndian(sequence)...) +} + +func BtcWithdrawRequestByTxHashKey(txid string, sequence uint64) []byte { + return append(append(BtcWithdrawRequestByTxHashKeyPrefix, []byte(txid)...), sdk.Uint64ToBigEndian(sequence)...) +} + +func BtcWithdrawRequestQueueKey(sequence uint64) []byte { + return append(BtcWithdrawRequestQueueKeyPrefix, sdk.Uint64ToBigEndian(sequence)...) +} + func BtcSigningRequestKey(sequence uint64) []byte { return append(BtcSigningRequestPrefix, sdk.Uint64ToBigEndian(sequence)...) } @@ -61,10 +78,6 @@ func BtcMintedTxHashKey(hash string) []byte { return append(BtcMintedTxHashKeyPrefix, []byte(hash)...) } -func BtcLockedAssetKey(txHash string, index uint8) []byte { - return append(append(BtcLockedAssetKeyPrefix, []byte(txHash)...), byte(index)) -} - func BtcUtxoKey(hash string, vout uint64) []byte { return append(append(BtcUtxoKeyPrefix, []byte(hash)...), sdk.Uint64ToBigEndian(vout)...) } @@ -76,6 +89,14 @@ func BtcOwnerUtxoKey(owner string, hash string, vout uint64) []byte { return key } +func BtcOwnerUtxoByAmountKey(owner string, amount uint64, hash string, vout uint64) []byte { + key := append(append(BtcOwnerUtxoByAmountKeyPrefix, []byte(owner)...), sdk.Uint64ToBigEndian(amount)...) + key = append(key, []byte(hash)...) + key = append(key, sdk.Uint64ToBigEndian(vout)...) + + return key +} + func BtcOwnerRunesUtxoKey(owner string, id string, hash string, vout uint64) []byte { key := append(append(BtcOwnerRunesUtxoKeyPrefix, []byte(owner)...), []byte(id)...) key = append(key, []byte(hash)...) diff --git a/x/btcbridge/types/message_submit_fee_rate.go b/x/btcbridge/types/message_submit_fee_rate.go new file mode 100644 index 00000000..5c1851b7 --- /dev/null +++ b/x/btcbridge/types/message_submit_fee_rate.go @@ -0,0 +1,52 @@ +package types + +import ( + sdkerrors "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +const TypeMsgSubmitFeeRate = "submit_fee_rate" + +func NewMsgSubmitFeeRate( + sender string, + feeRate int64, +) *MsgSubmitFeeRate { + return &MsgSubmitFeeRate{ + Sender: sender, + FeeRate: feeRate, + } +} + +func (msg *MsgSubmitFeeRate) Route() string { + return RouterKey +} + +func (msg *MsgSubmitFeeRate) Type() string { + return TypeMsgSubmitFeeRate +} + +func (msg *MsgSubmitFeeRate) GetSigners() []sdk.AccAddress { + Sender, err := sdk.AccAddressFromBech32(msg.Sender) + if err != nil { + panic(err) + } + return []sdk.AccAddress{Sender} +} + +func (msg *MsgSubmitFeeRate) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +func (msg *MsgSubmitFeeRate) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Sender) + if err != nil { + return sdkerrors.Wrapf(err, "invalid sender address (%s)", err) + } + + if msg.FeeRate <= 0 { + return ErrInvalidFeeRate + } + + return nil +} diff --git a/x/btcbridge/types/message_update_non_btc_relayers.go b/x/btcbridge/types/message_update_trusted_non_btc_relayers.go similarity index 59% rename from x/btcbridge/types/message_update_non_btc_relayers.go rename to x/btcbridge/types/message_update_trusted_non_btc_relayers.go index 865daa05..a0ea4b7a 100644 --- a/x/btcbridge/types/message_update_non_btc_relayers.go +++ b/x/btcbridge/types/message_update_trusted_non_btc_relayers.go @@ -5,27 +5,27 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" ) -const TypeMsgUpdateNonBtcRelayers = "update_non_btc_relayers" +const TypeMsgUpdateTrustedNonBtcRelayers = "update_trusted_non_btc_relayers" -func NewMsgUpdateNonBtcRelayers( +func NewMsgUpdateTrustedNonBtcRelayers( sender string, relayers []string, -) *MsgUpdateNonBtcRelayers { - return &MsgUpdateNonBtcRelayers{ +) *MsgUpdateTrustedNonBtcRelayers { + return &MsgUpdateTrustedNonBtcRelayers{ Sender: sender, Relayers: relayers, } } -func (msg *MsgUpdateNonBtcRelayers) Route() string { +func (msg *MsgUpdateTrustedNonBtcRelayers) Route() string { return RouterKey } -func (msg *MsgUpdateNonBtcRelayers) Type() string { - return TypeMsgUpdateNonBtcRelayers +func (msg *MsgUpdateTrustedNonBtcRelayers) Type() string { + return TypeMsgUpdateTrustedNonBtcRelayers } -func (msg *MsgUpdateNonBtcRelayers) GetSigners() []sdk.AccAddress { +func (msg *MsgUpdateTrustedNonBtcRelayers) GetSigners() []sdk.AccAddress { Sender, err := sdk.AccAddressFromBech32(msg.Sender) if err != nil { panic(err) @@ -33,12 +33,12 @@ func (msg *MsgUpdateNonBtcRelayers) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{Sender} } -func (msg *MsgUpdateNonBtcRelayers) GetSignBytes() []byte { +func (msg *MsgUpdateTrustedNonBtcRelayers) GetSignBytes() []byte { bz := ModuleCdc.MustMarshalJSON(msg) return sdk.MustSortJSON(bz) } -func (msg *MsgUpdateNonBtcRelayers) ValidateBasic() error { +func (msg *MsgUpdateTrustedNonBtcRelayers) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(msg.Sender) if err != nil { return sdkerrors.Wrapf(err, "invalid sender address (%s)", err) diff --git a/x/btcbridge/types/message_update_trusted_oracles.go b/x/btcbridge/types/message_update_trusted_oracles.go new file mode 100644 index 00000000..d6a44b15 --- /dev/null +++ b/x/btcbridge/types/message_update_trusted_oracles.go @@ -0,0 +1,59 @@ +package types + +import ( + sdkerrors "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +const TypeMsgUpdateTrustedOracles = "update_trusted_oracles" + +func NewMsgUpdateTrustedOracles( + sender string, + oracles []string, +) *MsgUpdateTrustedOracles { + return &MsgUpdateTrustedOracles{ + Sender: sender, + Oracles: oracles, + } +} + +func (msg *MsgUpdateTrustedOracles) Route() string { + return RouterKey +} + +func (msg *MsgUpdateTrustedOracles) Type() string { + return TypeMsgUpdateTrustedOracles +} + +func (msg *MsgUpdateTrustedOracles) GetSigners() []sdk.AccAddress { + Sender, err := sdk.AccAddressFromBech32(msg.Sender) + if err != nil { + panic(err) + } + return []sdk.AccAddress{Sender} +} + +func (msg *MsgUpdateTrustedOracles) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +func (msg *MsgUpdateTrustedOracles) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Sender) + if err != nil { + return sdkerrors.Wrapf(err, "invalid sender address (%s)", err) + } + + if len(msg.Oracles) == 0 { + return sdkerrors.Wrapf(ErrInvalidOracles, "oracles can not be empty") + } + + for _, oracle := range msg.Oracles { + _, err := sdk.AccAddressFromBech32(oracle) + if err != nil { + return sdkerrors.Wrapf(err, "invalid oracle address (%s)", err) + } + } + + return nil +} diff --git a/x/btcbridge/types/message_withdraw_to_bitcoin.go b/x/btcbridge/types/message_withdraw_to_bitcoin.go index 1a0afb55..21056ae9 100644 --- a/x/btcbridge/types/message_withdraw_to_bitcoin.go +++ b/x/btcbridge/types/message_withdraw_to_bitcoin.go @@ -1,8 +1,6 @@ package types import ( - "strconv" - sdkerrors "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" ) @@ -12,12 +10,10 @@ const TypeMsgWithdrawToBitcoin = "withdraw_to_bitcoin" func NewMsgWithdrawToBitcoin( sender string, amount string, - feeRate string, ) *MsgWithdrawToBitcoin { return &MsgWithdrawToBitcoin{ - Sender: sender, - Amount: amount, - FeeRate: feeRate, + Sender: sender, + Amount: amount, } } @@ -53,14 +49,5 @@ func (msg *MsgWithdrawToBitcoin) ValidateBasic() error { return sdkerrors.Wrapf(ErrInvalidAmount, "invalid amount %s", msg.Amount) } - feeRate, err := strconv.ParseInt(msg.FeeRate, 10, 64) - if err != nil { - return err - } - - if feeRate <= 0 { - return sdkerrors.Wrap(ErrInvalidFeeRate, "fee rate must be greater than zero") - } - return nil } diff --git a/x/btcbridge/types/params.go b/x/btcbridge/types/params.go index bce4ef94..500f4744 100644 --- a/x/btcbridge/types/params.go +++ b/x/btcbridge/types/params.go @@ -15,6 +15,15 @@ import ( ) var ( + // default maximum number of utxos used to build the signing request + DefaultMaxUtxoNum = uint32(500) + + // default btc batch withdrawal period + DefaultBtcBatchWithdrawPeriod = int64(10) + + // default maximum number of btc batch withdrawal per batch + DefaultMaxBtcBatchWithdrawNum = uint32(100) + // default DKG timeout period DefaultDKGTimeoutPeriod = time.Duration(86400) * time.Second // 1 day @@ -30,8 +39,14 @@ func NewParams() Params { BtcVoucherDenom: "sat", DepositEnabled: true, WithdrawEnabled: true, - NonBtcRelayers: []string{}, + TrustedNonBtcRelayers: []string{}, + TrustedOracles: []string{}, Vaults: []*Vault{}, + WithdrawParams: WithdrawParams{ + MaxUtxoNum: DefaultMaxUtxoNum, + BtcBatchWithdrawPeriod: DefaultBtcBatchWithdrawPeriod, + MaxBtcBatchWithdrawNum: DefaultMaxBtcBatchWithdrawNum, + }, ProtocolLimits: ProtocolLimits{ BtcMinDeposit: 50000, // 0.0005 BTC BtcMinWithdraw: 30000, // 0.0003 BTC @@ -60,7 +75,11 @@ func (p Params) Validate() error { return err } - if err := validateNonBtcRelayers(p.NonBtcRelayers); err != nil { + if err := validateNonBtcRelayers(p.TrustedNonBtcRelayers); err != nil { + return err + } + + if err := validateOracles(p.TrustedOracles); err != nil { return err } @@ -68,6 +87,10 @@ func (p Params) Validate() error { return err } + if err := validateWithdrawParams(&p.WithdrawParams); err != nil { + return err + } + if err := validateProtocolParams(&p.ProtocolLimits, &p.ProtocolFees); err != nil { return err } @@ -138,13 +161,29 @@ func SelectVaultByPkScript(vaults []*Vault, pkScript []byte) *Vault { // validateNonBtcRelayers validates the given relayers func validateNonBtcRelayers(relayers []string) error { if len(relayers) == 0 { - return ErrInvalidParams + return ErrInvalidRelayers } for _, relayer := range relayers { _, err := sdk.AccAddressFromBech32(relayer) if err != nil { - return ErrInvalidParams + return ErrInvalidRelayers + } + } + + return nil +} + +// validateOracles validates the given oracles +func validateOracles(oracles []string) error { + if len(oracles) == 0 { + return ErrInvalidOracles + } + + for _, oracle := range oracles { + _, err := sdk.AccAddressFromBech32(oracle) + if err != nil { + return ErrInvalidOracles } } @@ -187,6 +226,14 @@ func validateVaults(vaults []*Vault) error { return nil } +func validateWithdrawParams(withdrawParams *WithdrawParams) error { + if withdrawParams.BtcBatchWithdrawPeriod == 0 || withdrawParams.MaxBtcBatchWithdrawNum == 0 { + return ErrInvalidParams + } + + return nil +} + // validateProtocolParams validates the given protocol limits and fees func validateProtocolParams(protocolLimits *ProtocolLimits, protocolFees *ProtocolFees) error { if protocolLimits.BtcMinWithdraw > protocolLimits.BtcMaxWithdraw { diff --git a/x/btcbridge/types/params.pb.go b/x/btcbridge/types/params.pb.go index b180bf03..3c91881c 100644 --- a/x/btcbridge/types/params.pb.go +++ b/x/btcbridge/types/params.pb.go @@ -77,15 +77,19 @@ type Params struct { // Indicates if withdrawal is enabled WithdrawEnabled bool `protobuf:"varint,5,opt,name=withdraw_enabled,json=withdrawEnabled,proto3" json:"withdraw_enabled,omitempty"` // Trusted relayers for non-btc asset deposit - NonBtcRelayers []string `protobuf:"bytes,6,rep,name=non_btc_relayers,json=nonBtcRelayers,proto3" json:"non_btc_relayers,omitempty"` + TrustedNonBtcRelayers []string `protobuf:"bytes,6,rep,name=trusted_non_btc_relayers,json=trustedNonBtcRelayers,proto3" json:"trusted_non_btc_relayers,omitempty"` + // Trusted oracles for providing offchain data, e.g. bitcoin fee rate + TrustedOracles []string `protobuf:"bytes,7,rep,name=trusted_oracles,json=trustedOracles,proto3" json:"trusted_oracles,omitempty"` // Asset vaults - Vaults []*Vault `protobuf:"bytes,7,rep,name=vaults,proto3" json:"vaults,omitempty"` + Vaults []*Vault `protobuf:"bytes,8,rep,name=vaults,proto3" json:"vaults,omitempty"` + // Withdrawal params + WithdrawParams WithdrawParams `protobuf:"bytes,9,opt,name=withdraw_params,json=withdrawParams,proto3" json:"withdraw_params"` // Protocol limitations - ProtocolLimits ProtocolLimits `protobuf:"bytes,8,opt,name=protocol_limits,json=protocolLimits,proto3" json:"protocol_limits"` + ProtocolLimits ProtocolLimits `protobuf:"bytes,10,opt,name=protocol_limits,json=protocolLimits,proto3" json:"protocol_limits"` // Protocol fees - ProtocolFees ProtocolFees `protobuf:"bytes,9,opt,name=protocol_fees,json=protocolFees,proto3" json:"protocol_fees"` + ProtocolFees ProtocolFees `protobuf:"bytes,11,opt,name=protocol_fees,json=protocolFees,proto3" json:"protocol_fees"` // TSS params - TssParams TSSParams `protobuf:"bytes,10,opt,name=tss_params,json=tssParams,proto3" json:"tss_params"` + TssParams TSSParams `protobuf:"bytes,12,opt,name=tss_params,json=tssParams,proto3" json:"tss_params"` } func (m *Params) Reset() { *m = Params{} } @@ -156,9 +160,16 @@ func (m *Params) GetWithdrawEnabled() bool { return false } -func (m *Params) GetNonBtcRelayers() []string { +func (m *Params) GetTrustedNonBtcRelayers() []string { if m != nil { - return m.NonBtcRelayers + return m.TrustedNonBtcRelayers + } + return nil +} + +func (m *Params) GetTrustedOracles() []string { + if m != nil { + return m.TrustedOracles } return nil } @@ -170,6 +181,13 @@ func (m *Params) GetVaults() []*Vault { return nil } +func (m *Params) GetWithdrawParams() WithdrawParams { + if m != nil { + return m.WithdrawParams + } + return WithdrawParams{} +} + func (m *Params) GetProtocolLimits() ProtocolLimits { if m != nil { return m.ProtocolLimits @@ -264,6 +282,69 @@ func (m *Vault) GetVersion() uint64 { return 0 } +type WithdrawParams struct { + // Maximum number of utxos used to build the signing request; O means unlimited + MaxUtxoNum uint32 `protobuf:"varint,1,opt,name=max_utxo_num,json=maxUtxoNum,proto3" json:"max_utxo_num,omitempty"` + // Period for handling btc withdrawal requests + BtcBatchWithdrawPeriod int64 `protobuf:"varint,2,opt,name=btc_batch_withdraw_period,json=btcBatchWithdrawPeriod,proto3" json:"btc_batch_withdraw_period,omitempty"` + // Maximum number of btc withdrawal requests to be handled per batch + MaxBtcBatchWithdrawNum uint32 `protobuf:"varint,3,opt,name=max_btc_batch_withdraw_num,json=maxBtcBatchWithdrawNum,proto3" json:"max_btc_batch_withdraw_num,omitempty"` +} + +func (m *WithdrawParams) Reset() { *m = WithdrawParams{} } +func (m *WithdrawParams) String() string { return proto.CompactTextString(m) } +func (*WithdrawParams) ProtoMessage() {} +func (*WithdrawParams) Descriptor() ([]byte, []int) { + return fileDescriptor_f1d33573cda8a6d2, []int{2} +} +func (m *WithdrawParams) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WithdrawParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_WithdrawParams.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 *WithdrawParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_WithdrawParams.Merge(m, src) +} +func (m *WithdrawParams) XXX_Size() int { + return m.Size() +} +func (m *WithdrawParams) XXX_DiscardUnknown() { + xxx_messageInfo_WithdrawParams.DiscardUnknown(m) +} + +var xxx_messageInfo_WithdrawParams proto.InternalMessageInfo + +func (m *WithdrawParams) GetMaxUtxoNum() uint32 { + if m != nil { + return m.MaxUtxoNum + } + return 0 +} + +func (m *WithdrawParams) GetBtcBatchWithdrawPeriod() int64 { + if m != nil { + return m.BtcBatchWithdrawPeriod + } + return 0 +} + +func (m *WithdrawParams) GetMaxBtcBatchWithdrawNum() uint32 { + if m != nil { + return m.MaxBtcBatchWithdrawNum + } + return 0 +} + // ProtocolLimits defines the params related to the the protocol limitations type ProtocolLimits struct { // The minimum deposit amount for btc in sat @@ -278,7 +359,7 @@ func (m *ProtocolLimits) Reset() { *m = ProtocolLimits{} } func (m *ProtocolLimits) String() string { return proto.CompactTextString(m) } func (*ProtocolLimits) ProtoMessage() {} func (*ProtocolLimits) Descriptor() ([]byte, []int) { - return fileDescriptor_f1d33573cda8a6d2, []int{2} + return fileDescriptor_f1d33573cda8a6d2, []int{3} } func (m *ProtocolLimits) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -342,7 +423,7 @@ func (m *ProtocolFees) Reset() { *m = ProtocolFees{} } func (m *ProtocolFees) String() string { return proto.CompactTextString(m) } func (*ProtocolFees) ProtoMessage() {} func (*ProtocolFees) Descriptor() ([]byte, []int) { - return fileDescriptor_f1d33573cda8a6d2, []int{3} + return fileDescriptor_f1d33573cda8a6d2, []int{4} } func (m *ProtocolFees) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -404,7 +485,7 @@ func (m *TSSParams) Reset() { *m = TSSParams{} } func (m *TSSParams) String() string { return proto.CompactTextString(m) } func (*TSSParams) ProtoMessage() {} func (*TSSParams) Descriptor() ([]byte, []int) { - return fileDescriptor_f1d33573cda8a6d2, []int{4} + return fileDescriptor_f1d33573cda8a6d2, []int{5} } func (m *TSSParams) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -451,6 +532,7 @@ func init() { proto.RegisterEnum("side.btcbridge.AssetType", AssetType_name, AssetType_value) proto.RegisterType((*Params)(nil), "side.btcbridge.Params") proto.RegisterType((*Vault)(nil), "side.btcbridge.Vault") + proto.RegisterType((*WithdrawParams)(nil), "side.btcbridge.WithdrawParams") proto.RegisterType((*ProtocolLimits)(nil), "side.btcbridge.ProtocolLimits") proto.RegisterType((*ProtocolFees)(nil), "side.btcbridge.ProtocolFees") proto.RegisterType((*TSSParams)(nil), "side.btcbridge.TSSParams") @@ -459,59 +541,66 @@ func init() { func init() { proto.RegisterFile("side/btcbridge/params.proto", fileDescriptor_f1d33573cda8a6d2) } var fileDescriptor_f1d33573cda8a6d2 = []byte{ - // 821 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x94, 0x4f, 0x6f, 0xe3, 0x44, - 0x18, 0xc6, 0xe3, 0x26, 0x4d, 0xeb, 0x69, 0x9b, 0x86, 0xd1, 0xc2, 0x9a, 0xb2, 0x4a, 0xb3, 0xd1, - 0x0a, 0xc2, 0x4a, 0xc4, 0x6c, 0xb9, 0x20, 0x21, 0x21, 0x35, 0x4d, 0x0a, 0x2b, 0xd8, 0x55, 0x70, - 0xd2, 0x45, 0x70, 0x19, 0x8d, 0xc7, 0x6f, 0xdd, 0x51, 0x6d, 0x8f, 0xe5, 0x19, 0x77, 0x93, 0xef, - 0x80, 0x10, 0x47, 0x0e, 0x7c, 0xa0, 0x3d, 0xee, 0x81, 0x03, 0x27, 0x40, 0xed, 0x17, 0x41, 0x33, - 0xfe, 0xd3, 0xb4, 0x08, 0x89, 0x9b, 0xe7, 0x79, 0x7f, 0xf3, 0xbc, 0x63, 0xbf, 0x8f, 0x07, 0x7d, - 0x20, 0x79, 0x00, 0xae, 0xaf, 0x98, 0x9f, 0xf1, 0x20, 0x04, 0x37, 0xa5, 0x19, 0x8d, 0xe5, 0x28, - 0xcd, 0x84, 0x12, 0xb8, 0xa3, 0x8b, 0xa3, 0xba, 0x78, 0xf0, 0x20, 0x14, 0xa1, 0x30, 0x25, 0x57, - 0x3f, 0x15, 0xd4, 0x41, 0x2f, 0x14, 0x22, 0x8c, 0xc0, 0x35, 0x2b, 0x3f, 0x3f, 0x77, 0x83, 0x3c, - 0xa3, 0x8a, 0x8b, 0xa4, 0xaa, 0x33, 0x21, 0x63, 0x21, 0x5d, 0x9f, 0x4a, 0x70, 0xaf, 0x9e, 0xf9, - 0xa0, 0xe8, 0x33, 0x97, 0x09, 0x5e, 0xd6, 0x07, 0xbf, 0xb5, 0x50, 0x7b, 0x66, 0xda, 0xe2, 0x27, - 0x68, 0x8f, 0x89, 0xe4, 0x9c, 0x67, 0xb1, 0x31, 0x90, 0x8e, 0xd5, 0xb7, 0x86, 0x9b, 0xde, 0x5d, - 0x11, 0x7f, 0x81, 0x0e, 0x62, 0xba, 0x24, 0x94, 0x31, 0x48, 0x15, 0xf5, 0x23, 0x20, 0x7e, 0x24, - 0xd8, 0x25, 0x09, 0x20, 0x55, 0x17, 0xce, 0x46, 0xdf, 0x1a, 0xb6, 0xbc, 0x87, 0x31, 0x5d, 0x1e, - 0xd7, 0xc0, 0x58, 0xd7, 0x27, 0xba, 0x8c, 0x9f, 0xa2, 0x77, 0x7c, 0xc5, 0xc8, 0x95, 0xc8, 0xd9, - 0x05, 0x64, 0x24, 0x80, 0x44, 0xc4, 0x4e, 0xb3, 0x6f, 0x0d, 0x6d, 0x6f, 0xdf, 0x57, 0xec, 0x55, - 0xa1, 0x4f, 0xb4, 0x8c, 0x3f, 0x42, 0xfb, 0x01, 0xa4, 0x42, 0x72, 0x45, 0x20, 0xd1, 0x3e, 0x81, - 0xd3, 0xea, 0x5b, 0xc3, 0x6d, 0xaf, 0x53, 0xca, 0xd3, 0x42, 0xc5, 0x1f, 0xa3, 0xee, 0x6b, 0xae, - 0x2e, 0x82, 0x8c, 0xbe, 0xae, 0xc9, 0x4d, 0x43, 0xee, 0x57, 0x7a, 0x85, 0x0e, 0x51, 0x37, 0x11, - 0x09, 0xd1, 0x67, 0xc8, 0x20, 0xa2, 0x2b, 0xc8, 0xa4, 0xd3, 0xee, 0x37, 0x87, 0xb6, 0xd7, 0x49, - 0x44, 0x32, 0x56, 0xcc, 0x2b, 0x55, 0xfc, 0x09, 0x6a, 0x5f, 0xd1, 0x3c, 0x52, 0xd2, 0xd9, 0xea, - 0x37, 0x87, 0x3b, 0x47, 0xef, 0x8e, 0xee, 0x8e, 0x63, 0xf4, 0x4a, 0x57, 0xbd, 0x12, 0xc2, 0x2f, - 0xd0, 0xbe, 0xf9, 0x9e, 0x4c, 0x44, 0x24, 0xe2, 0x31, 0x57, 0xd2, 0xd9, 0xee, 0x5b, 0xc3, 0x9d, - 0xa3, 0xde, 0xfd, 0x7d, 0xb3, 0x12, 0xfb, 0xd6, 0x50, 0xe3, 0xd6, 0x9b, 0x3f, 0x0f, 0x1b, 0x5e, - 0x27, 0xbd, 0xa3, 0xe2, 0xaf, 0xd0, 0x5e, 0x6d, 0x77, 0x0e, 0x20, 0x1d, 0xdb, 0x98, 0x3d, 0xfa, - 0x2f, 0xb3, 0x53, 0x80, 0xca, 0x6a, 0x37, 0x5d, 0xd3, 0xf0, 0x97, 0x08, 0x29, 0x29, 0x49, 0x11, - 0x2c, 0x07, 0x19, 0x97, 0xf7, 0xef, 0xbb, 0x2c, 0xe6, 0xf3, 0x22, 0x02, 0xa5, 0x85, 0xad, 0xa4, - 0x2c, 0x84, 0xc1, 0xcf, 0x16, 0xda, 0x34, 0x6f, 0x8a, 0x1d, 0xb4, 0x45, 0x83, 0x20, 0x03, 0x59, - 0xe4, 0xc2, 0xf6, 0xaa, 0x25, 0x7e, 0x88, 0xb6, 0xd2, 0xdc, 0x27, 0x97, 0xb0, 0x32, 0xe3, 0xb7, - 0xbd, 0x76, 0x9a, 0xfb, 0xdf, 0xc0, 0x0a, 0x7f, 0x8e, 0x10, 0x95, 0x12, 0x14, 0x51, 0xab, 0x14, - 0xcc, 0x98, 0x3b, 0xff, 0x6e, 0x7e, 0xac, 0x89, 0xc5, 0x2a, 0x05, 0xcf, 0xa6, 0xd5, 0xa3, 0x6e, - 0x76, 0x05, 0x99, 0xe4, 0x22, 0x31, 0x33, 0x6f, 0x79, 0xd5, 0x72, 0xf0, 0x93, 0x85, 0x3a, 0x77, - 0x3f, 0x21, 0xfe, 0x10, 0xe9, 0xec, 0x90, 0x98, 0x27, 0xa4, 0x4c, 0x86, 0x39, 0x61, 0xd3, 0xdb, - 0xf3, 0x15, 0x7b, 0xc1, 0x93, 0x49, 0x21, 0xea, 0xe1, 0x57, 0x5c, 0x95, 0x0b, 0x73, 0xe0, 0xa6, - 0xd7, 0x29, 0xc0, 0xef, 0x4b, 0xb5, 0x26, 0xe9, 0xf2, 0x96, 0x6c, 0xde, 0x92, 0x74, 0x59, 0x91, - 0x83, 0x14, 0xed, 0xae, 0xcf, 0x00, 0x1f, 0xa2, 0x9d, 0x2a, 0xb4, 0xe7, 0x00, 0xe5, 0x39, 0x50, - 0x29, 0x9d, 0x02, 0xe0, 0xc7, 0x68, 0xb7, 0x0e, 0xab, 0x26, 0x8a, 0x03, 0xec, 0x54, 0x9a, 0x46, - 0x1e, 0x21, 0x9b, 0x89, 0x28, 0x02, 0xa6, 0x44, 0x56, 0xfe, 0x1c, 0xb7, 0xc2, 0xe0, 0x77, 0x0b, - 0xd9, 0xf5, 0xc0, 0xf0, 0x77, 0x08, 0x07, 0x97, 0x21, 0x51, 0x3c, 0x06, 0x91, 0x2b, 0x92, 0x42, - 0xc6, 0x45, 0x60, 0xda, 0xea, 0x39, 0x17, 0x77, 0xc3, 0xa8, 0xba, 0x1b, 0x46, 0x93, 0xf2, 0x6e, - 0x18, 0x6f, 0xeb, 0x39, 0xff, 0xfa, 0xd7, 0xa1, 0xe5, 0x75, 0x83, 0xcb, 0x70, 0x51, 0xec, 0x9e, - 0x99, 0xcd, 0x58, 0xa1, 0x27, 0x29, 0xcd, 0x14, 0x67, 0x3c, 0xa5, 0x89, 0x22, 0x79, 0x1a, 0x50, - 0x05, 0x44, 0x65, 0x34, 0x91, 0x5c, 0x6f, 0xae, 0x9a, 0x6c, 0xfc, 0xff, 0x26, 0x8f, 0xd7, 0x0c, - 0xcf, 0x8c, 0xdf, 0xa2, 0xb6, 0x2b, 0xba, 0x3e, 0x0d, 0x91, 0x5d, 0x27, 0x01, 0x1f, 0xa0, 0xf7, - 0x8e, 0xe7, 0xf3, 0xe9, 0x82, 0x2c, 0x7e, 0x98, 0x4d, 0xc9, 0xd9, 0xcb, 0xf9, 0x6c, 0x7a, 0xf2, - 0xfc, 0xf4, 0xf9, 0x74, 0xd2, 0x6d, 0x60, 0x8c, 0x3a, 0x6b, 0xb5, 0xf1, 0xe2, 0xa4, 0x6b, 0xe1, - 0x07, 0xa8, 0xbb, 0xae, 0x79, 0x27, 0x47, 0x9f, 0x76, 0x37, 0xee, 0xa9, 0xde, 0xd9, 0xcb, 0xe9, - 0xbc, 0xdb, 0x1c, 0x7f, 0xfd, 0xe6, 0xba, 0x67, 0xbd, 0xbd, 0xee, 0x59, 0x7f, 0x5f, 0xf7, 0xac, - 0x5f, 0x6e, 0x7a, 0x8d, 0xb7, 0x37, 0xbd, 0xc6, 0x1f, 0x37, 0xbd, 0xc6, 0x8f, 0xa3, 0x90, 0xab, - 0x8b, 0xdc, 0x1f, 0x31, 0x11, 0xbb, 0x3a, 0xa4, 0xd5, 0x8f, 0x64, 0x16, 0xee, 0x72, 0xed, 0x9e, - 0xd6, 0x79, 0x96, 0x7e, 0xdb, 0x00, 0x9f, 0xfd, 0x13, 0x00, 0x00, 0xff, 0xff, 0xe6, 0x85, 0x91, - 0x53, 0xc6, 0x05, 0x00, 0x00, + // 936 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x55, 0xcf, 0x6f, 0x1b, 0x45, + 0x14, 0xf6, 0xd6, 0x89, 0x9b, 0x7d, 0x76, 0x1c, 0x33, 0x6a, 0xd3, 0x6d, 0xa8, 0x1c, 0xd7, 0xaa, + 0xc0, 0x54, 0xc2, 0x4b, 0xc3, 0x81, 0x5f, 0x12, 0x52, 0x1c, 0x3b, 0x50, 0x41, 0x4d, 0x58, 0x3b, + 0x45, 0x70, 0x19, 0xcd, 0xce, 0x4e, 0xec, 0x55, 0x76, 0x77, 0x56, 0x3b, 0xb3, 0x89, 0xfd, 0x3f, + 0x20, 0xc4, 0x91, 0x3b, 0x27, 0xfe, 0x93, 0x1e, 0x7b, 0xe0, 0xc0, 0x09, 0x50, 0xf2, 0x8f, 0xa0, + 0x99, 0xfd, 0x11, 0x3b, 0x14, 0x89, 0x9b, 0xe7, 0xfb, 0xbe, 0xf7, 0xbd, 0x37, 0xfb, 0xde, 0x1b, + 0xc3, 0xdb, 0xc2, 0xf7, 0x98, 0xed, 0x4a, 0xea, 0x26, 0xbe, 0x37, 0x63, 0x76, 0x4c, 0x12, 0x12, + 0x8a, 0x7e, 0x9c, 0x70, 0xc9, 0x51, 0x53, 0x91, 0xfd, 0x92, 0xdc, 0xbb, 0x37, 0xe3, 0x33, 0xae, + 0x29, 0x5b, 0xfd, 0xca, 0x54, 0x7b, 0xed, 0x19, 0xe7, 0xb3, 0x80, 0xd9, 0xfa, 0xe4, 0xa6, 0x67, + 0xb6, 0x97, 0x26, 0x44, 0xfa, 0x3c, 0x2a, 0x78, 0xca, 0x45, 0xc8, 0x85, 0xed, 0x12, 0xc1, 0xec, + 0x8b, 0x67, 0x2e, 0x93, 0xe4, 0x99, 0x4d, 0xb9, 0x9f, 0xf3, 0xdd, 0x5f, 0x37, 0xa1, 0x76, 0xa2, + 0xd3, 0xa2, 0x27, 0xb0, 0x4d, 0x79, 0x74, 0xe6, 0x27, 0xa1, 0x36, 0x10, 0x96, 0xd1, 0x31, 0x7a, + 0x9b, 0xce, 0x3a, 0x88, 0x3e, 0x83, 0xbd, 0x90, 0x2c, 0x30, 0xa1, 0x94, 0xc5, 0x92, 0xb8, 0x01, + 0xc3, 0x6e, 0xc0, 0xe9, 0x39, 0xf6, 0x58, 0x2c, 0xe7, 0xd6, 0x9d, 0x8e, 0xd1, 0xdb, 0x70, 0x1e, + 0x84, 0x64, 0x71, 0x58, 0x0a, 0x06, 0x8a, 0x1f, 0x2a, 0x1a, 0x3d, 0x85, 0xb7, 0x5c, 0x49, 0xf1, + 0x05, 0x4f, 0xe9, 0x9c, 0x25, 0xd8, 0x63, 0x11, 0x0f, 0xad, 0x6a, 0xc7, 0xe8, 0x99, 0xce, 0x8e, + 0x2b, 0xe9, 0xcb, 0x0c, 0x1f, 0x2a, 0x18, 0xbd, 0x0b, 0x3b, 0x1e, 0x8b, 0xb9, 0xf0, 0x25, 0x66, + 0x91, 0xf2, 0xf1, 0xac, 0x8d, 0x8e, 0xd1, 0xdb, 0x72, 0x9a, 0x39, 0x3c, 0xca, 0x50, 0xf4, 0x1e, + 0xb4, 0x2e, 0x7d, 0x39, 0xf7, 0x12, 0x72, 0x59, 0x2a, 0x37, 0xb5, 0x72, 0xa7, 0xc0, 0x0b, 0xe9, + 0x47, 0x60, 0xc9, 0x24, 0x15, 0x92, 0x79, 0x38, 0xe2, 0x11, 0x56, 0xb5, 0x24, 0x2c, 0x20, 0x4b, + 0x96, 0x08, 0xab, 0xd6, 0xa9, 0xf6, 0x4c, 0xe7, 0x7e, 0xce, 0x8f, 0x79, 0x34, 0x90, 0xd4, 0xc9, + 0x49, 0x55, 0x4c, 0x11, 0xc8, 0x13, 0x42, 0x03, 0x26, 0xac, 0xbb, 0x5a, 0xdf, 0xcc, 0xe1, 0x6f, + 0x32, 0x14, 0xbd, 0x0f, 0xb5, 0x0b, 0x92, 0x06, 0x52, 0x58, 0x5b, 0x9d, 0x6a, 0xaf, 0x7e, 0x70, + 0xbf, 0xbf, 0xde, 0xc6, 0xfe, 0x4b, 0xc5, 0x3a, 0xb9, 0x08, 0xbd, 0x80, 0xb2, 0x46, 0x9c, 0x75, + 0xdf, 0x32, 0x3b, 0x46, 0xaf, 0x7e, 0xd0, 0xbe, 0x1d, 0xf7, 0x5d, 0x2e, 0xcb, 0x9a, 0x35, 0xd8, + 0x78, 0xf5, 0xe7, 0x7e, 0xc5, 0x69, 0x5e, 0xae, 0xa1, 0xca, 0x4e, 0xb7, 0x95, 0xf2, 0x00, 0x07, + 0x7e, 0xe8, 0x4b, 0x61, 0xc1, 0x9b, 0xed, 0x4e, 0x72, 0xd9, 0xd7, 0x5a, 0x55, 0xd8, 0xc5, 0x6b, + 0x28, 0xfa, 0x02, 0xb6, 0x4b, 0xbb, 0x33, 0xc6, 0x84, 0x55, 0xd7, 0x66, 0x8f, 0xfe, 0xcb, 0xec, + 0x98, 0xb1, 0xc2, 0xaa, 0x11, 0xaf, 0x60, 0xe8, 0x73, 0x00, 0x29, 0x44, 0x71, 0xc3, 0x86, 0x76, + 0x79, 0x78, 0xdb, 0x65, 0x3a, 0x99, 0xac, 0x5d, 0xce, 0x94, 0x42, 0x64, 0x40, 0xf7, 0x27, 0x03, + 0x36, 0xf5, 0x87, 0x43, 0x16, 0xdc, 0x25, 0x9e, 0x97, 0x30, 0x91, 0x8d, 0xa7, 0xe9, 0x14, 0x47, + 0xf4, 0x00, 0xee, 0xc6, 0xa9, 0x8b, 0xcf, 0xd9, 0x52, 0x4f, 0xa1, 0xe9, 0xd4, 0xe2, 0xd4, 0xfd, + 0x8a, 0x2d, 0xd1, 0xc7, 0x00, 0x44, 0x08, 0x26, 0xb1, 0x5c, 0xc6, 0x4c, 0x4f, 0x5b, 0xf3, 0xdf, + 0xc9, 0x0f, 0x95, 0x62, 0xba, 0x8c, 0x99, 0x63, 0x92, 0xe2, 0xa7, 0x4a, 0x76, 0xc1, 0x12, 0xe1, + 0xf3, 0x48, 0x8f, 0xde, 0x86, 0x53, 0x1c, 0xbb, 0xbf, 0x19, 0xd0, 0x5c, 0xef, 0x08, 0xea, 0x40, + 0x43, 0x2d, 0x46, 0x2a, 0x17, 0x1c, 0x47, 0x69, 0xa8, 0xcb, 0xdb, 0x76, 0x20, 0x24, 0x8b, 0x53, + 0xb9, 0xe0, 0xe3, 0x34, 0x44, 0x9f, 0xc0, 0x43, 0x35, 0x71, 0x2e, 0x91, 0x74, 0x8e, 0x6f, 0xda, + 0xce, 0x12, 0x9f, 0x7b, 0xba, 0xe6, 0xaa, 0xb3, 0xeb, 0x4a, 0x3a, 0x50, 0x7c, 0x69, 0xae, 0x59, + 0xf4, 0x69, 0xb6, 0x75, 0x6f, 0x08, 0x57, 0xa9, 0xaa, 0x3a, 0xd5, 0x6e, 0x48, 0x16, 0x83, 0x5b, + 0xe1, 0xe3, 0x34, 0xec, 0xfe, 0x68, 0x40, 0x73, 0xbd, 0xdd, 0xe8, 0x1d, 0x50, 0xeb, 0x86, 0x43, + 0x3f, 0xc2, 0xf9, 0x32, 0xe9, 0x72, 0xab, 0xce, 0xb6, 0x2b, 0xe9, 0x0b, 0x3f, 0x1a, 0x66, 0x20, + 0xea, 0x41, 0xab, 0xd0, 0x15, 0x09, 0xf3, 0x42, 0x9b, 0x99, 0xb0, 0xc8, 0x53, 0x2a, 0xc9, 0xe2, + 0x46, 0x59, 0xbd, 0x51, 0x92, 0x45, 0xa1, 0xec, 0xc6, 0xd0, 0x58, 0x9d, 0x17, 0xb4, 0x0f, 0xf5, + 0x62, 0xcf, 0xcf, 0x18, 0xcb, 0xeb, 0x80, 0x1c, 0x3a, 0x66, 0x0c, 0x3d, 0x86, 0x46, 0x79, 0x5b, + 0xa5, 0xc8, 0x0a, 0xa8, 0x17, 0x98, 0x92, 0x3c, 0x02, 0x93, 0xf2, 0x20, 0x60, 0x54, 0xf2, 0x24, + 0x7f, 0x4f, 0x6e, 0x80, 0xee, 0xef, 0x06, 0x98, 0xe5, 0x70, 0xa1, 0x6f, 0x01, 0x79, 0xe7, 0x33, + 0x2c, 0xfd, 0x90, 0xf1, 0x54, 0x16, 0x9f, 0xdf, 0xc8, 0x67, 0x32, 0x7b, 0x4e, 0xfb, 0xc5, 0x73, + 0xda, 0x1f, 0xe6, 0xcf, 0xe9, 0x60, 0x4b, 0xcd, 0xe4, 0x2f, 0x7f, 0xed, 0x1b, 0x4e, 0xcb, 0x3b, + 0x9f, 0x4d, 0xb3, 0xe8, 0xbc, 0x3b, 0x12, 0x9e, 0xc4, 0x24, 0x91, 0x3e, 0xf5, 0x63, 0x12, 0x49, + 0x9c, 0xc6, 0x1e, 0x91, 0x0c, 0xcb, 0x84, 0x44, 0xc2, 0x57, 0xc1, 0xab, 0x3d, 0xfe, 0x9f, 0x49, + 0x1e, 0xaf, 0x18, 0x9e, 0x6a, 0xbf, 0x69, 0x69, 0x97, 0x65, 0x7d, 0x3a, 0x03, 0xb3, 0x9c, 0x5a, + 0xb4, 0x07, 0xbb, 0x87, 0x93, 0xc9, 0x68, 0x8a, 0xa7, 0xdf, 0x9f, 0x8c, 0xf0, 0xe9, 0x78, 0x72, + 0x32, 0x3a, 0x7a, 0x7e, 0xfc, 0x7c, 0x34, 0x6c, 0x55, 0x10, 0x82, 0xe6, 0x0a, 0x37, 0x98, 0x1e, + 0xb5, 0x0c, 0x74, 0x0f, 0x5a, 0xab, 0x98, 0x73, 0x74, 0xf0, 0x41, 0xeb, 0xce, 0x2d, 0xd4, 0x39, + 0x1d, 0x8f, 0x26, 0xad, 0xea, 0xe0, 0xcb, 0x57, 0x57, 0x6d, 0xe3, 0xf5, 0x55, 0xdb, 0xf8, 0xfb, + 0xaa, 0x6d, 0xfc, 0x7c, 0xdd, 0xae, 0xbc, 0xbe, 0x6e, 0x57, 0xfe, 0xb8, 0x6e, 0x57, 0x7e, 0xe8, + 0xcf, 0x7c, 0x39, 0x4f, 0xdd, 0x3e, 0xe5, 0xa1, 0xad, 0x16, 0xaa, 0x58, 0x7a, 0x7d, 0xb0, 0x17, + 0x2b, 0x7f, 0x6d, 0x6a, 0xf7, 0x84, 0x5b, 0xd3, 0x82, 0x0f, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, + 0xc7, 0xe1, 0xeb, 0x42, 0xf9, 0x06, 0x00, 0x00, } func (m *Params) Marshal() (dAtA []byte, err error) { @@ -543,7 +632,7 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintParams(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x52 + dAtA[i] = 0x62 { size, err := m.ProtocolFees.MarshalToSizedBuffer(dAtA[:i]) if err != nil { @@ -553,7 +642,7 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintParams(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x4a + dAtA[i] = 0x5a { size, err := m.ProtocolLimits.MarshalToSizedBuffer(dAtA[:i]) if err != nil { @@ -563,7 +652,17 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintParams(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x42 + dAtA[i] = 0x52 + { + size, err := m.WithdrawParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintParams(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a if len(m.Vaults) > 0 { for iNdEx := len(m.Vaults) - 1; iNdEx >= 0; iNdEx-- { { @@ -575,14 +674,23 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintParams(dAtA, i, uint64(size)) } i-- + dAtA[i] = 0x42 + } + } + if len(m.TrustedOracles) > 0 { + for iNdEx := len(m.TrustedOracles) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.TrustedOracles[iNdEx]) + copy(dAtA[i:], m.TrustedOracles[iNdEx]) + i = encodeVarintParams(dAtA, i, uint64(len(m.TrustedOracles[iNdEx]))) + i-- dAtA[i] = 0x3a } } - if len(m.NonBtcRelayers) > 0 { - for iNdEx := len(m.NonBtcRelayers) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.NonBtcRelayers[iNdEx]) - copy(dAtA[i:], m.NonBtcRelayers[iNdEx]) - i = encodeVarintParams(dAtA, i, uint64(len(m.NonBtcRelayers[iNdEx]))) + if len(m.TrustedNonBtcRelayers) > 0 { + for iNdEx := len(m.TrustedNonBtcRelayers) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.TrustedNonBtcRelayers[iNdEx]) + copy(dAtA[i:], m.TrustedNonBtcRelayers[iNdEx]) + i = encodeVarintParams(dAtA, i, uint64(len(m.TrustedNonBtcRelayers[iNdEx]))) i-- dAtA[i] = 0x32 } @@ -674,6 +782,44 @@ func (m *Vault) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *WithdrawParams) 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 *WithdrawParams) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WithdrawParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.MaxBtcBatchWithdrawNum != 0 { + i = encodeVarintParams(dAtA, i, uint64(m.MaxBtcBatchWithdrawNum)) + i-- + dAtA[i] = 0x18 + } + if m.BtcBatchWithdrawPeriod != 0 { + i = encodeVarintParams(dAtA, i, uint64(m.BtcBatchWithdrawPeriod)) + i-- + dAtA[i] = 0x10 + } + if m.MaxUtxoNum != 0 { + i = encodeVarintParams(dAtA, i, uint64(m.MaxUtxoNum)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func (m *ProtocolLimits) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -772,21 +918,21 @@ func (m *TSSParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - n4, err4 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.ParticipantUpdateTransitionPeriod, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.ParticipantUpdateTransitionPeriod):]) - if err4 != nil { - return 0, err4 - } - i -= n4 - i = encodeVarintParams(dAtA, i, uint64(n4)) - i-- - dAtA[i] = 0x12 - n5, err5 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.DkgTimeoutPeriod, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.DkgTimeoutPeriod):]) + n5, err5 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.ParticipantUpdateTransitionPeriod, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.ParticipantUpdateTransitionPeriod):]) if err5 != nil { return 0, err5 } i -= n5 i = encodeVarintParams(dAtA, i, uint64(n5)) i-- + dAtA[i] = 0x12 + n6, err6 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.DkgTimeoutPeriod, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.DkgTimeoutPeriod):]) + if err6 != nil { + return 0, err6 + } + i -= n6 + i = encodeVarintParams(dAtA, i, uint64(n6)) + i-- dAtA[i] = 0xa return len(dAtA) - i, nil } @@ -824,8 +970,14 @@ func (m *Params) Size() (n int) { if m.WithdrawEnabled { n += 2 } - if len(m.NonBtcRelayers) > 0 { - for _, s := range m.NonBtcRelayers { + if len(m.TrustedNonBtcRelayers) > 0 { + for _, s := range m.TrustedNonBtcRelayers { + l = len(s) + n += 1 + l + sovParams(uint64(l)) + } + } + if len(m.TrustedOracles) > 0 { + for _, s := range m.TrustedOracles { l = len(s) n += 1 + l + sovParams(uint64(l)) } @@ -836,6 +988,8 @@ func (m *Params) Size() (n int) { n += 1 + l + sovParams(uint64(l)) } } + l = m.WithdrawParams.Size() + n += 1 + l + sovParams(uint64(l)) l = m.ProtocolLimits.Size() n += 1 + l + sovParams(uint64(l)) l = m.ProtocolFees.Size() @@ -868,6 +1022,24 @@ func (m *Vault) Size() (n int) { return n } +func (m *WithdrawParams) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MaxUtxoNum != 0 { + n += 1 + sovParams(uint64(m.MaxUtxoNum)) + } + if m.BtcBatchWithdrawPeriod != 0 { + n += 1 + sovParams(uint64(m.BtcBatchWithdrawPeriod)) + } + if m.MaxBtcBatchWithdrawNum != 0 { + n += 1 + sovParams(uint64(m.MaxBtcBatchWithdrawNum)) + } + return n +} + func (m *ProtocolLimits) Size() (n int) { if m == nil { return 0 @@ -1065,7 +1237,7 @@ func (m *Params) Unmarshal(dAtA []byte) error { m.WithdrawEnabled = bool(v != 0) case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NonBtcRelayers", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TrustedNonBtcRelayers", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -1093,9 +1265,41 @@ func (m *Params) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.NonBtcRelayers = append(m.NonBtcRelayers, string(dAtA[iNdEx:postIndex])) + m.TrustedNonBtcRelayers = append(m.TrustedNonBtcRelayers, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TrustedOracles", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + 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 ErrInvalidLengthParams + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthParams + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TrustedOracles = append(m.TrustedOracles, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Vaults", wireType) } @@ -1129,7 +1333,40 @@ func (m *Params) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 8: + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WithdrawParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthParams + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthParams + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.WithdrawParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ProtocolLimits", wireType) } @@ -1162,7 +1399,7 @@ func (m *Params) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 9: + case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ProtocolFees", wireType) } @@ -1195,7 +1432,7 @@ func (m *Params) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 10: + case 12: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TssParams", wireType) } @@ -1401,6 +1638,113 @@ func (m *Vault) Unmarshal(dAtA []byte) error { } return nil } +func (m *WithdrawParams) 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 ErrIntOverflowParams + } + 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: WithdrawParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WithdrawParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxUtxoNum", wireType) + } + m.MaxUtxoNum = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxUtxoNum |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BtcBatchWithdrawPeriod", wireType) + } + m.BtcBatchWithdrawPeriod = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BtcBatchWithdrawPeriod |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxBtcBatchWithdrawNum", wireType) + } + m.MaxBtcBatchWithdrawNum = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxBtcBatchWithdrawNum |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipParams(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthParams + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *ProtocolLimits) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/x/btcbridge/types/query.pb.go b/x/btcbridge/types/query.pb.go index 72df2e02..df596822 100644 --- a/x/btcbridge/types/query.pb.go +++ b/x/btcbridge/types/query.pb.go @@ -332,25 +332,22 @@ func (m *QuerySigningRequestByTxHashResponse) GetRequest() *SigningRequest { return nil } -// QueryWithdrawNetworkFeeRequest is request type for the Query/WithdrawNetworkFee RPC method. -type QueryWithdrawNetworkFeeRequest struct { - Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` - Amount string `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"` - FeeRate string `protobuf:"bytes,3,opt,name=fee_rate,json=feeRate,proto3" json:"fee_rate,omitempty"` +// QueryFeeRateRequest is request type for the Query/FeeRate RPC method. +type QueryFeeRateRequest struct { } -func (m *QueryWithdrawNetworkFeeRequest) Reset() { *m = QueryWithdrawNetworkFeeRequest{} } -func (m *QueryWithdrawNetworkFeeRequest) String() string { return proto.CompactTextString(m) } -func (*QueryWithdrawNetworkFeeRequest) ProtoMessage() {} -func (*QueryWithdrawNetworkFeeRequest) Descriptor() ([]byte, []int) { +func (m *QueryFeeRateRequest) Reset() { *m = QueryFeeRateRequest{} } +func (m *QueryFeeRateRequest) String() string { return proto.CompactTextString(m) } +func (*QueryFeeRateRequest) ProtoMessage() {} +func (*QueryFeeRateRequest) Descriptor() ([]byte, []int) { return fileDescriptor_fb547edb49d5502d, []int{6} } -func (m *QueryWithdrawNetworkFeeRequest) XXX_Unmarshal(b []byte) error { +func (m *QueryFeeRateRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *QueryWithdrawNetworkFeeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *QueryFeeRateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_QueryWithdrawNetworkFeeRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_QueryFeeRateRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -360,56 +357,35 @@ func (m *QueryWithdrawNetworkFeeRequest) XXX_Marshal(b []byte, deterministic boo return b[:n], nil } } -func (m *QueryWithdrawNetworkFeeRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_QueryWithdrawNetworkFeeRequest.Merge(m, src) +func (m *QueryFeeRateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryFeeRateRequest.Merge(m, src) } -func (m *QueryWithdrawNetworkFeeRequest) XXX_Size() int { +func (m *QueryFeeRateRequest) XXX_Size() int { return m.Size() } -func (m *QueryWithdrawNetworkFeeRequest) XXX_DiscardUnknown() { - xxx_messageInfo_QueryWithdrawNetworkFeeRequest.DiscardUnknown(m) +func (m *QueryFeeRateRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryFeeRateRequest.DiscardUnknown(m) } -var xxx_messageInfo_QueryWithdrawNetworkFeeRequest proto.InternalMessageInfo +var xxx_messageInfo_QueryFeeRateRequest proto.InternalMessageInfo -func (m *QueryWithdrawNetworkFeeRequest) GetSender() string { - if m != nil { - return m.Sender - } - return "" -} - -func (m *QueryWithdrawNetworkFeeRequest) GetAmount() string { - if m != nil { - return m.Amount - } - return "" -} - -func (m *QueryWithdrawNetworkFeeRequest) GetFeeRate() string { - if m != nil { - return m.FeeRate - } - return "" +// QueryFeeRateResponse is response type for the Query/FeeRate RPC method. +type QueryFeeRateResponse struct { + FeeRate int64 `protobuf:"varint,1,opt,name=fee_rate,json=feeRate,proto3" json:"fee_rate,omitempty"` } -// QueryWithdrawNetworkFeeResponse is response type for the Query/WithdrawNetworkFee RPC method. -type QueryWithdrawNetworkFeeResponse struct { - Fee int64 `protobuf:"varint,1,opt,name=fee,proto3" json:"fee,omitempty"` -} - -func (m *QueryWithdrawNetworkFeeResponse) Reset() { *m = QueryWithdrawNetworkFeeResponse{} } -func (m *QueryWithdrawNetworkFeeResponse) String() string { return proto.CompactTextString(m) } -func (*QueryWithdrawNetworkFeeResponse) ProtoMessage() {} -func (*QueryWithdrawNetworkFeeResponse) Descriptor() ([]byte, []int) { +func (m *QueryFeeRateResponse) Reset() { *m = QueryFeeRateResponse{} } +func (m *QueryFeeRateResponse) String() string { return proto.CompactTextString(m) } +func (*QueryFeeRateResponse) ProtoMessage() {} +func (*QueryFeeRateResponse) Descriptor() ([]byte, []int) { return fileDescriptor_fb547edb49d5502d, []int{7} } -func (m *QueryWithdrawNetworkFeeResponse) XXX_Unmarshal(b []byte) error { +func (m *QueryFeeRateResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *QueryWithdrawNetworkFeeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *QueryFeeRateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_QueryWithdrawNetworkFeeResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_QueryFeeRateResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -419,21 +395,21 @@ func (m *QueryWithdrawNetworkFeeResponse) XXX_Marshal(b []byte, deterministic bo return b[:n], nil } } -func (m *QueryWithdrawNetworkFeeResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_QueryWithdrawNetworkFeeResponse.Merge(m, src) +func (m *QueryFeeRateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryFeeRateResponse.Merge(m, src) } -func (m *QueryWithdrawNetworkFeeResponse) XXX_Size() int { +func (m *QueryFeeRateResponse) XXX_Size() int { return m.Size() } -func (m *QueryWithdrawNetworkFeeResponse) XXX_DiscardUnknown() { - xxx_messageInfo_QueryWithdrawNetworkFeeResponse.DiscardUnknown(m) +func (m *QueryFeeRateResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryFeeRateResponse.DiscardUnknown(m) } -var xxx_messageInfo_QueryWithdrawNetworkFeeResponse proto.InternalMessageInfo +var xxx_messageInfo_QueryFeeRateResponse proto.InternalMessageInfo -func (m *QueryWithdrawNetworkFeeResponse) GetFee() int64 { +func (m *QueryFeeRateResponse) GetFeeRate() int64 { if m != nil { - return m.Fee + return m.FeeRate } return 0 } @@ -1436,8 +1412,8 @@ func init() { proto.RegisterType((*QuerySigningRequestsByAddressResponse)(nil), "side.btcbridge.QuerySigningRequestsByAddressResponse") proto.RegisterType((*QuerySigningRequestByTxHashRequest)(nil), "side.btcbridge.QuerySigningRequestByTxHashRequest") proto.RegisterType((*QuerySigningRequestByTxHashResponse)(nil), "side.btcbridge.QuerySigningRequestByTxHashResponse") - proto.RegisterType((*QueryWithdrawNetworkFeeRequest)(nil), "side.btcbridge.QueryWithdrawNetworkFeeRequest") - proto.RegisterType((*QueryWithdrawNetworkFeeResponse)(nil), "side.btcbridge.QueryWithdrawNetworkFeeResponse") + proto.RegisterType((*QueryFeeRateRequest)(nil), "side.btcbridge.QueryFeeRateRequest") + proto.RegisterType((*QueryFeeRateResponse)(nil), "side.btcbridge.QueryFeeRateResponse") proto.RegisterType((*QueryParamsRequest)(nil), "side.btcbridge.QueryParamsRequest") proto.RegisterType((*QueryParamsResponse)(nil), "side.btcbridge.QueryParamsResponse") proto.RegisterType((*QueryChainTipRequest)(nil), "side.btcbridge.QueryChainTipRequest") @@ -1465,94 +1441,90 @@ func init() { func init() { proto.RegisterFile("side/btcbridge/query.proto", fileDescriptor_fb547edb49d5502d) } var fileDescriptor_fb547edb49d5502d = []byte{ - // 1378 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcf, 0x6f, 0x13, 0xc7, - 0x17, 0xcf, 0xc6, 0x21, 0xc0, 0x04, 0xf8, 0xf2, 0x7d, 0x84, 0xe0, 0x6e, 0x92, 0xc5, 0x0c, 0x81, - 0xb8, 0x01, 0xbc, 0xc5, 0x06, 0x04, 0x1c, 0x5a, 0x70, 0xda, 0x92, 0x0a, 0xa9, 0xd0, 0x05, 0xd4, - 0xaa, 0x17, 0x3a, 0xb6, 0x27, 0xf6, 0x2a, 0xce, 0xae, 0xd9, 0x5d, 0x43, 0xac, 0x28, 0x97, 0xde, - 0x5a, 0xf5, 0x50, 0xa9, 0x95, 0xaa, 0xaa, 0xed, 0xa5, 0x95, 0x7a, 0xea, 0x1f, 0x50, 0xf5, 0x2f, - 0x40, 0x3d, 0x21, 0x55, 0xaa, 0x7a, 0xaa, 0x2a, 0xe8, 0x1f, 0x52, 0xed, 0xec, 0xdb, 0xb5, 0x3d, - 0xbb, 0xeb, 0x75, 0x68, 0x0e, 0xbd, 0x90, 0x9d, 0x99, 0xf7, 0xe3, 0xf3, 0xde, 0xbc, 0x79, 0xef, - 0x63, 0x88, 0xea, 0x9a, 0x0d, 0xae, 0xd7, 0xbc, 0x7a, 0xcd, 0x31, 0x1b, 0x4d, 0xae, 0x3f, 0xea, - 0x72, 0xa7, 0x57, 0xea, 0x38, 0xb6, 0x67, 0xc3, 0x11, 0xff, 0xac, 0x14, 0x9d, 0xa9, 0xb3, 0x4d, - 0xbb, 0x69, 0x8b, 0x23, 0xdd, 0xff, 0x0a, 0xa4, 0xd4, 0x85, 0xa6, 0x6d, 0x37, 0xdb, 0x5c, 0x67, - 0x1d, 0x53, 0x67, 0x96, 0x65, 0x7b, 0xcc, 0x33, 0x6d, 0xcb, 0xc5, 0xd3, 0x95, 0xba, 0xed, 0x6e, - 0xda, 0xae, 0x5e, 0x63, 0x2e, 0x1a, 0xd7, 0x1f, 0x5f, 0xac, 0x71, 0x8f, 0x5d, 0xd4, 0x3b, 0xac, - 0x69, 0x5a, 0x42, 0x18, 0x65, 0xe7, 0x25, 0x2c, 0x1d, 0xe6, 0xb0, 0xcd, 0xd0, 0x90, 0x26, 0x1d, - 0x46, 0x5f, 0xc1, 0x39, 0xfd, 0x4e, 0x21, 0xf3, 0xef, 0xf9, 0xf6, 0xef, 0x99, 0x4d, 0xcb, 0xb4, - 0x9a, 0x06, 0x7f, 0xd4, 0xe5, 0xae, 0xe7, 0xe2, 0x5f, 0xb8, 0x4c, 0xa6, 0x5d, 0x8f, 0x79, 0x5d, - 0x37, 0xaf, 0x14, 0x94, 0xe2, 0x91, 0xf2, 0x62, 0x69, 0x38, 0xba, 0x12, 0xea, 0xdd, 0x13, 0x42, - 0x06, 0x0a, 0xc3, 0x2d, 0x42, 0xfa, 0x38, 0xf3, 0x93, 0x05, 0xa5, 0x38, 0x53, 0x5e, 0x2e, 0x05, - 0x41, 0x95, 0xfc, 0xa0, 0x4a, 0x41, 0xc6, 0x30, 0xa8, 0xd2, 0x5d, 0xd6, 0xe4, 0x06, 0x77, 0x3b, - 0xb6, 0xe5, 0x72, 0x63, 0x40, 0x95, 0xfe, 0xa0, 0x90, 0x85, 0x64, 0x7c, 0x81, 0x30, 0x5c, 0x27, - 0x07, 0x1c, 0xdc, 0xcb, 0x2b, 0x85, 0x5c, 0x71, 0xa6, 0xac, 0xa5, 0x40, 0x44, 0x55, 0x23, 0x92, - 0xdf, 0x3b, 0x94, 0x9f, 0x28, 0x64, 0x29, 0x09, 0x65, 0xb5, 0x77, 0xb3, 0xd1, 0x70, 0xb8, 0x1b, - 0xa5, 0x33, 0x4f, 0xf6, 0xb3, 0x60, 0x47, 0xe4, 0xf3, 0xa0, 0x11, 0x2e, 0xf7, 0x0e, 0xcb, 0x4f, - 0x0a, 0x39, 0x93, 0x81, 0xe5, 0xbf, 0x94, 0xba, 0xab, 0x84, 0x26, 0xa0, 0xad, 0xf6, 0xee, 0x6f, - 0xad, 0x31, 0xb7, 0x15, 0xe6, 0x0d, 0xc8, 0x94, 0xb7, 0x65, 0x36, 0x30, 0x69, 0xe2, 0x9b, 0x3e, - 0x24, 0xa7, 0x47, 0x6a, 0x62, 0x94, 0x57, 0xc9, 0x7e, 0x44, 0x2d, 0xb4, 0xb3, 0x83, 0x0c, 0xc5, - 0xe9, 0x06, 0xd1, 0x84, 0x83, 0xf7, 0x4d, 0xaf, 0xd5, 0x70, 0xd8, 0x93, 0x77, 0xb9, 0xf7, 0xc4, - 0x76, 0x36, 0xde, 0xe6, 0x3c, 0x84, 0x35, 0x47, 0xa6, 0x5d, 0x6e, 0x35, 0xb8, 0x83, 0xc0, 0x70, - 0xe5, 0xef, 0xb3, 0x4d, 0xbb, 0x6b, 0x79, 0x22, 0x33, 0x07, 0x0d, 0x5c, 0xc1, 0x2b, 0xe4, 0xc0, - 0x3a, 0xe7, 0x0f, 0x1d, 0xe6, 0xf1, 0x7c, 0x2e, 0xb8, 0xff, 0x75, 0xce, 0x0d, 0xe6, 0x71, 0x5a, - 0x21, 0x27, 0x53, 0x9d, 0x61, 0x24, 0x47, 0x49, 0x6e, 0x9d, 0x73, 0xe1, 0x2a, 0x67, 0xf8, 0x9f, - 0x74, 0x96, 0x80, 0x50, 0xba, 0x2b, 0x9e, 0x3c, 0xa2, 0xa2, 0xb7, 0xc9, 0xb1, 0xa1, 0x5d, 0x54, - 0xbf, 0x44, 0xa6, 0x83, 0xd6, 0x80, 0x79, 0x98, 0x93, 0xf3, 0x10, 0xc8, 0x57, 0xa7, 0x9e, 0xfe, - 0x79, 0x72, 0xc2, 0x40, 0x59, 0x3a, 0x47, 0x66, 0x85, 0xb1, 0xd5, 0x16, 0x33, 0xad, 0xfb, 0x66, - 0x27, 0x74, 0xb2, 0x4a, 0x8e, 0x4b, 0xfb, 0xe8, 0x06, 0xc8, 0x54, 0x8b, 0xb9, 0xad, 0xf0, 0xaa, - 0xfc, 0x6f, 0x3f, 0x1f, 0x2d, 0x6e, 0x36, 0x5b, 0x41, 0x3e, 0xa6, 0x0c, 0x5c, 0xd1, 0x6b, 0x18, - 0x74, 0xb5, 0x6d, 0xd7, 0x37, 0xd6, 0x38, 0x6b, 0x70, 0xa7, 0xda, 0x5b, 0x13, 0x67, 0x03, 0x29, - 0x46, 0x55, 0x65, 0x48, 0xb5, 0x46, 0x0a, 0xe9, 0xaa, 0x08, 0xe5, 0x75, 0x72, 0xa8, 0xe6, 0x1f, - 0x3f, 0x6c, 0x89, 0x73, 0x8c, 0x7b, 0x5e, 0x8e, 0x7b, 0xc0, 0x84, 0x31, 0x53, 0xeb, 0x2f, 0x68, - 0x85, 0x2c, 0x26, 0xf8, 0x18, 0x2e, 0x4b, 0x39, 0x56, 0xfa, 0x11, 0x56, 0x4d, 0x82, 0xd2, 0x1e, - 0xc1, 0x3a, 0x46, 0xfe, 0x2f, 0x3c, 0x3c, 0xb8, 0xff, 0xc1, 0x9d, 0xe8, 0xd2, 0x6f, 0x60, 0x29, - 0xe0, 0x26, 0xba, 0x5a, 0x21, 0xfb, 0xba, 0xde, 0x96, 0x1d, 0xbe, 0xef, 0x59, 0xd9, 0x87, 0x2f, - 0x6d, 0x04, 0x22, 0xf4, 0x0a, 0x51, 0xfb, 0x16, 0xc6, 0xef, 0x5c, 0xf4, 0x1d, 0x9c, 0x20, 0xb2, - 0xde, 0x4b, 0x40, 0x78, 0x8b, 0xbc, 0x1a, 0x99, 0x5a, 0xf5, 0x5f, 0xcc, 0x4d, 0xab, 0x51, 0x65, - 0x6d, 0x66, 0xd5, 0xf9, 0x6e, 0x10, 0x7d, 0xad, 0x90, 0x95, 0x71, 0xec, 0x20, 0xc2, 0x59, 0xb2, - 0xaf, 0x2e, 0x1e, 0xab, 0x6f, 0xe6, 0xb0, 0x11, 0x2c, 0xfc, 0xdd, 0xc7, 0xac, 0xdd, 0xe5, 0xa2, - 0x64, 0x73, 0x46, 0xb0, 0x80, 0x37, 0xc8, 0x21, 0xa7, 0x6b, 0xf1, 0xd0, 0x58, 0x3e, 0x27, 0x82, - 0x8a, 0xdd, 0x9d, 0xd1, 0x97, 0x31, 0x86, 0x14, 0x68, 0x91, 0xcc, 0x09, 0x68, 0x6f, 0xde, 0xbe, - 0x15, 0x36, 0x1c, 0x8c, 0xe7, 0x08, 0x99, 0xc4, 0x0e, 0x37, 0x65, 0x4c, 0x9a, 0x0d, 0x7a, 0x87, - 0x9c, 0x88, 0x49, 0x46, 0x4f, 0x59, 0xea, 0x69, 0xaa, 0x0c, 0x60, 0x40, 0x29, 0xea, 0x67, 0xf7, - 0x62, 0x06, 0xa3, 0x5c, 0x5e, 0x95, 0xc6, 0x7c, 0x21, 0xdd, 0xde, 0xf0, 0xa4, 0xa7, 0x06, 0xc9, - 0xc7, 0x8d, 0x22, 0xcc, 0x2b, 0xb1, 0x01, 0x33, 0x0a, 0x67, 0x24, 0x4b, 0x17, 0xb0, 0x12, 0x6f, - 0xb6, 0xdb, 0x71, 0xac, 0xf4, 0x01, 0xd6, 0x9b, 0x7c, 0xfa, 0x2f, 0x9d, 0x56, 0xc8, 0xa9, 0x30, - 0x90, 0x55, 0x7b, 0xb3, 0xd3, 0xe6, 0xfe, 0x78, 0x92, 0xf3, 0x24, 0xdf, 0xd1, 0x3a, 0x4e, 0xaf, - 0x14, 0x25, 0x84, 0x74, 0x23, 0x06, 0x69, 0x29, 0x01, 0x52, 0xcc, 0x40, 0x1f, 0x5c, 0xf9, 0x77, - 0x20, 0xfb, 0x84, 0x23, 0x78, 0x4c, 0x66, 0x06, 0x9a, 0x3b, 0x50, 0xd9, 0x50, 0x7c, 0x1e, 0xa8, - 0xa7, 0x47, 0xca, 0x04, 0x18, 0xa9, 0xf6, 0xf1, 0x6f, 0x7f, 0x7f, 0x31, 0x99, 0x87, 0x39, 0x3d, - 0x91, 0x4e, 0x42, 0x8f, 0x1c, 0x1e, 0xea, 0xf7, 0xb0, 0x94, 0x68, 0x55, 0x1a, 0x13, 0xea, 0x99, - 0x0c, 0x29, 0xf4, 0x3e, 0x2f, 0xbc, 0x1f, 0x87, 0x63, 0xb2, 0x77, 0xcf, 0xec, 0xc0, 0x8f, 0x0a, - 0xd6, 0x58, 0x42, 0xaf, 0x07, 0x3d, 0xd1, 0x41, 0xfa, 0x40, 0x51, 0x5f, 0x1b, 0x5f, 0x01, 0xc1, - 0x2d, 0x0b, 0x70, 0xa7, 0xe0, 0xa4, 0x0c, 0x2e, 0x18, 0x45, 0xfa, 0x76, 0xf0, 0x77, 0x07, 0xbe, - 0x55, 0xf0, 0x71, 0xc7, 0x7a, 0x3f, 0x5c, 0x18, 0xc3, 0x6b, 0x7f, 0xb0, 0xa8, 0xa5, 0x71, 0xc5, - 0x11, 0xe2, 0x69, 0x01, 0x71, 0x11, 0xe6, 0x63, 0x10, 0x99, 0xdb, 0xd2, 0xb7, 0xfd, 0x7f, 0x77, - 0xe0, 0x1b, 0x05, 0x67, 0xb9, 0xc4, 0x0c, 0xe1, 0x5c, 0xa2, 0xb7, 0xe4, 0x5f, 0x04, 0xea, 0xf9, - 0xf1, 0x84, 0x11, 0x58, 0x51, 0x00, 0xa3, 0x50, 0x90, 0x81, 0xb9, 0x81, 0x82, 0x1e, 0x31, 0xca, - 0xa7, 0x0a, 0x4e, 0xdb, 0x34, 0xde, 0x0a, 0x97, 0xc6, 0xf1, 0x2c, 0x8f, 0x09, 0xf5, 0xf2, 0x2e, - 0xb5, 0x10, 0xf8, 0x75, 0x01, 0xfc, 0x12, 0x94, 0xb3, 0x80, 0xeb, 0x38, 0x75, 0xf4, 0x6d, 0xfc, - 0xd8, 0x81, 0x5f, 0x92, 0x7f, 0x54, 0x85, 0xd4, 0x14, 0xca, 0x63, 0x40, 0x92, 0x18, 0xb0, 0x5a, - 0xd9, 0x95, 0x0e, 0x06, 0x51, 0x16, 0x41, 0x9c, 0x87, 0x95, 0xcc, 0x20, 0xbc, 0x2d, 0x7d, 0xdb, - 0x67, 0xd5, 0x3b, 0xf0, 0xbd, 0x82, 0x63, 0x22, 0xce, 0x44, 0x21, 0xb9, 0x2c, 0x53, 0xf9, 0xb1, - 0xaa, 0x8f, 0x2d, 0x8f, 0x80, 0xcf, 0x0a, 0xc0, 0x05, 0xd0, 0x64, 0xc0, 0x4f, 0x50, 0x87, 0xb5, - 0xf5, 0x75, 0xce, 0xc1, 0x21, 0xa4, 0xcf, 0x39, 0xe0, 0x54, 0xa2, 0x9b, 0x41, 0x7a, 0xa4, 0xd2, - 0x51, 0x22, 0xe8, 0x7c, 0x51, 0x38, 0x3f, 0x01, 0xc7, 0x65, 0xe7, 0x82, 0x9c, 0xc0, 0x57, 0x0a, - 0xf2, 0xea, 0x61, 0xa2, 0x03, 0x2b, 0xe9, 0xa6, 0x63, 0xc5, 0x78, 0x6e, 0x2c, 0xd9, 0xac, 0xbe, - 0x23, 0xf0, 0x0c, 0xd4, 0xdb, 0xaf, 0x0a, 0x8e, 0xa1, 0x91, 0x7c, 0x07, 0xae, 0xa5, 0x3a, 0xcf, - 0xe2, 0x5a, 0xea, 0xf5, 0x97, 0x51, 0xc5, 0x30, 0x2e, 0x88, 0x30, 0x96, 0xe1, 0x4c, 0x46, 0x18, - 0xba, 0xcf, 0x28, 0x5c, 0xf8, 0x4c, 0x21, 0xff, 0x93, 0x18, 0x05, 0x9c, 0x4d, 0x74, 0x1f, 0xa3, - 0x50, 0xea, 0x72, 0xa6, 0x5c, 0x56, 0x5b, 0x6a, 0x6c, 0x44, 0x8f, 0x42, 0xdf, 0xf6, 0x9f, 0xc3, - 0xa7, 0x0a, 0x39, 0x2a, 0x13, 0x1c, 0xc8, 0xf2, 0x13, 0xe5, 0xad, 0x98, 0x2d, 0x98, 0xd5, 0xc1, - 0x07, 0x10, 0xc1, 0x97, 0x61, 0x09, 0x0e, 0x73, 0x9f, 0x94, 0x12, 0x4c, 0xa4, 0x4f, 0x29, 0x25, - 0x98, 0x4c, 0xa6, 0xe8, 0x92, 0x40, 0xa5, 0xc1, 0xc2, 0x08, 0x54, 0x2e, 0xfc, 0xac, 0x20, 0x61, - 0x4b, 0xa4, 0x41, 0x70, 0x31, 0x2d, 0x09, 0xa9, 0x3c, 0x4b, 0x2d, 0xef, 0x46, 0x05, 0xb1, 0x56, - 0x04, 0xd6, 0x0b, 0x70, 0x2e, 0x09, 0x6b, 0x3d, 0xd2, 0x1b, 0xba, 0xde, 0xea, 0xda, 0xd3, 0xe7, - 0x9a, 0xf2, 0xec, 0xb9, 0xa6, 0xfc, 0xf5, 0x5c, 0x53, 0x3e, 0x7f, 0xa1, 0x4d, 0x3c, 0x7b, 0xa1, - 0x4d, 0xfc, 0xf1, 0x42, 0x9b, 0xf8, 0xb0, 0xd4, 0x34, 0xbd, 0x56, 0xb7, 0x56, 0xaa, 0xdb, 0x9b, - 0xc2, 0xa0, 0xf8, 0xff, 0xb2, 0xba, 0xdd, 0x0e, 0xac, 0x6f, 0x0d, 0x72, 0x94, 0x5e, 0x87, 0xbb, - 0xb5, 0x69, 0x21, 0x50, 0xf9, 0x27, 0x00, 0x00, 0xff, 0xff, 0x8d, 0xb6, 0xf7, 0xad, 0x1b, 0x14, - 0x00, 0x00, + // 1327 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x98, 0x4f, 0x6f, 0x1b, 0xc5, + 0x1b, 0xc7, 0xb3, 0x49, 0x9a, 0xf6, 0xf7, 0xa4, 0xed, 0x0f, 0x9e, 0x26, 0xa9, 0xbb, 0x49, 0x1c, + 0x77, 0x9b, 0x12, 0x93, 0x34, 0x5e, 0xe2, 0xa4, 0x55, 0x9a, 0x03, 0x34, 0x0e, 0xd0, 0xa0, 0x1e, + 0x5a, 0x36, 0xa9, 0x84, 0xb8, 0x84, 0xb5, 0x3d, 0xb1, 0x57, 0x75, 0x76, 0x5d, 0xef, 0x3a, 0x8a, + 0x89, 0x72, 0xe1, 0x06, 0xe2, 0x80, 0x04, 0x12, 0x42, 0xc0, 0x09, 0x89, 0x13, 0xdc, 0x11, 0xaf, + 0x20, 0xe2, 0x54, 0x89, 0x0b, 0x27, 0x84, 0x12, 0x5e, 0x08, 0xda, 0xd9, 0x67, 0xd7, 0xf6, 0xec, + 0xae, 0xd7, 0x29, 0x39, 0x70, 0x69, 0x76, 0x67, 0x9e, 0x3f, 0x9f, 0x67, 0x66, 0x76, 0x9e, 0xaf, + 0x0b, 0xb2, 0x6d, 0x94, 0x99, 0x5a, 0x74, 0x4a, 0xc5, 0x86, 0x51, 0xae, 0x30, 0xf5, 0x79, 0x93, + 0x35, 0x5a, 0xb9, 0x7a, 0xc3, 0x72, 0x2c, 0xbc, 0xea, 0xce, 0xe5, 0x82, 0x39, 0x79, 0xac, 0x62, + 0x55, 0x2c, 0x3e, 0xa5, 0xba, 0x4f, 0x9e, 0x95, 0x3c, 0x55, 0xb1, 0xac, 0x4a, 0x8d, 0xa9, 0x7a, + 0xdd, 0x50, 0x75, 0xd3, 0xb4, 0x1c, 0xdd, 0x31, 0x2c, 0xd3, 0xa6, 0xd9, 0xf9, 0x92, 0x65, 0xef, + 0x59, 0xb6, 0x5a, 0xd4, 0x6d, 0x0a, 0xae, 0xee, 0x2f, 0x15, 0x99, 0xa3, 0x2f, 0xa9, 0x75, 0xbd, + 0x62, 0x98, 0xdc, 0x98, 0x6c, 0x27, 0x05, 0x96, 0xba, 0xde, 0xd0, 0xf7, 0xfc, 0x40, 0x69, 0x61, + 0x32, 0x78, 0xf2, 0xe6, 0x95, 0xef, 0x25, 0x98, 0x7c, 0xdf, 0x8d, 0xbf, 0x65, 0x54, 0x4c, 0xc3, + 0xac, 0x68, 0xec, 0x79, 0x93, 0xd9, 0x8e, 0x4d, 0x7f, 0xf1, 0x2e, 0x8c, 0xd8, 0x8e, 0xee, 0x34, + 0xed, 0x94, 0x94, 0x91, 0xb2, 0x57, 0xf3, 0xd3, 0xb9, 0xee, 0xea, 0x72, 0xe4, 0xb7, 0xc5, 0x8d, + 0x34, 0x32, 0xc6, 0x87, 0x00, 0x6d, 0xce, 0xd4, 0x60, 0x46, 0xca, 0x8e, 0xe6, 0xe7, 0x72, 0x5e, + 0x51, 0x39, 0xb7, 0xa8, 0x9c, 0xb7, 0x62, 0x54, 0x54, 0xee, 0x89, 0x5e, 0x61, 0x1a, 0xb3, 0xeb, + 0x96, 0x69, 0x33, 0xad, 0xc3, 0x55, 0xf9, 0x41, 0x82, 0xa9, 0x68, 0x3e, 0xcf, 0x18, 0xd7, 0xe0, + 0x52, 0x83, 0xc6, 0x52, 0x52, 0x66, 0x28, 0x3b, 0x9a, 0x4f, 0xc7, 0x20, 0x92, 0xab, 0x16, 0xd8, + 0x9f, 0x1f, 0xe5, 0xa7, 0x12, 0xcc, 0x46, 0x51, 0x16, 0x5a, 0xeb, 0xe5, 0x72, 0x83, 0xd9, 0xc1, + 0x72, 0xa6, 0xe0, 0xa2, 0xee, 0x8d, 0xf0, 0xf5, 0xfc, 0x9f, 0xe6, 0xbf, 0x9e, 0x1f, 0xcb, 0x4f, + 0x12, 0xdc, 0x4e, 0x60, 0xf9, 0x2f, 0x2d, 0xdd, 0x2a, 0x28, 0x11, 0xb4, 0x85, 0xd6, 0xf6, 0xc1, + 0xa6, 0x6e, 0x57, 0xfd, 0x75, 0x43, 0x18, 0x76, 0x0e, 0x8c, 0x32, 0x2d, 0x1a, 0x7f, 0x56, 0x76, + 0xe0, 0x56, 0x4f, 0x4f, 0xaa, 0x72, 0x15, 0x2e, 0x12, 0x35, 0xf7, 0x4e, 0x2e, 0xd2, 0x37, 0x57, + 0xc6, 0xe1, 0x1a, 0x4f, 0xf0, 0x2e, 0x63, 0x9a, 0xee, 0x30, 0x9a, 0x57, 0x96, 0x60, 0xac, 0x7b, + 0x98, 0x12, 0xdd, 0x80, 0x4b, 0xbb, 0x8c, 0xed, 0x34, 0x74, 0x87, 0xf1, 0x4c, 0x43, 0xda, 0xc5, + 0x5d, 0xcf, 0x44, 0x19, 0x03, 0xe4, 0x2e, 0x4f, 0xf8, 0xa7, 0xe9, 0x07, 0x7a, 0x44, 0xf1, 0xfd, + 0x51, 0x8a, 0xb3, 0x02, 0x23, 0xde, 0x27, 0x4c, 0xbc, 0x13, 0x22, 0xaf, 0x67, 0x5f, 0x18, 0x3e, + 0xfe, 0x73, 0x66, 0x40, 0x23, 0x5b, 0x65, 0x82, 0xa8, 0x36, 0xaa, 0xba, 0x61, 0x6e, 0x1b, 0x75, + 0x3f, 0xc9, 0x06, 0x8c, 0x0b, 0xe3, 0x94, 0x06, 0x61, 0xb8, 0xaa, 0xdb, 0x55, 0x7f, 0x49, 0xdd, + 0x67, 0x9c, 0x80, 0x91, 0x2a, 0x33, 0x2a, 0x55, 0x87, 0xef, 0xe8, 0xb0, 0x46, 0x6f, 0xca, 0x7d, + 0x98, 0xe1, 0x41, 0x0a, 0x35, 0xab, 0xf4, 0x6c, 0x93, 0xe9, 0x65, 0xd6, 0x28, 0xb4, 0x36, 0xf9, + 0x9c, 0xbf, 0x43, 0x6d, 0x57, 0xa9, 0xcb, 0xb5, 0x08, 0x99, 0x78, 0x57, 0x42, 0x79, 0x13, 0x2e, + 0x17, 0xdd, 0xe9, 0x9d, 0x2a, 0x9f, 0xa7, 0xba, 0x27, 0xc5, 0xba, 0x3b, 0x42, 0x68, 0xa3, 0xc5, + 0xf6, 0x8b, 0xb2, 0x0c, 0xd3, 0x11, 0x39, 0xba, 0x8f, 0x8f, 0x58, 0xab, 0xf2, 0x11, 0xa4, 0xe3, + 0x9c, 0xce, 0x09, 0xeb, 0x1a, 0xbc, 0xca, 0x33, 0x3c, 0xdd, 0xfe, 0xe0, 0x71, 0xb0, 0xe9, 0x0f, + 0xe8, 0x28, 0xd0, 0x20, 0xa5, 0x9a, 0x87, 0x0b, 0x4d, 0xe7, 0xc0, 0xf2, 0xbf, 0xc3, 0x31, 0x31, + 0x87, 0x6b, 0xad, 0x79, 0x26, 0xca, 0x3d, 0x90, 0xdb, 0x11, 0xfa, 0xbf, 0x61, 0x94, 0xf7, 0xe8, + 0xa6, 0x17, 0xfd, 0x5e, 0x02, 0xe1, 0x1d, 0x78, 0x3d, 0x08, 0xb5, 0x61, 0x35, 0x4d, 0x67, 0xdd, + 0x2c, 0x17, 0xf4, 0x9a, 0x6e, 0x96, 0xd8, 0x59, 0x88, 0xbe, 0x91, 0x60, 0xbe, 0x9f, 0x38, 0x44, + 0x38, 0x06, 0x17, 0x4a, 0xae, 0x11, 0x0f, 0x73, 0x45, 0xf3, 0x5e, 0xdc, 0xd1, 0x7d, 0xbd, 0xd6, + 0x64, 0xfc, 0xc8, 0x0e, 0x69, 0xde, 0x0b, 0xbe, 0x05, 0x97, 0x1b, 0x4d, 0x93, 0xf9, 0xc1, 0x52, + 0x43, 0xbc, 0xa8, 0xd0, 0xde, 0x69, 0x6d, 0x1b, 0xad, 0xcb, 0x41, 0xc9, 0xc2, 0x04, 0x47, 0x7b, + 0xfb, 0xd1, 0x43, 0xff, 0x62, 0xa0, 0x7a, 0xae, 0xc2, 0x20, 0xdd, 0x44, 0xc3, 0xda, 0xa0, 0x51, + 0x56, 0x1e, 0xc3, 0xf5, 0x90, 0x65, 0xf0, 0x29, 0x0b, 0x77, 0x8f, 0x2c, 0x02, 0x74, 0x38, 0x05, + 0xf7, 0xce, 0x56, 0x28, 0x60, 0xb0, 0x96, 0xab, 0x42, 0x3b, 0xce, 0xc4, 0xc7, 0xeb, 0xee, 0xc8, + 0x8a, 0x06, 0xa9, 0x70, 0x50, 0xc2, 0xbc, 0x17, 0x6a, 0x04, 0xbd, 0x38, 0x03, 0x5b, 0x65, 0x8a, + 0x4e, 0xe2, 0x7a, 0xad, 0x16, 0x66, 0x55, 0x9e, 0xd2, 0x79, 0x13, 0x67, 0xff, 0x65, 0xd2, 0x65, + 0xb8, 0xe9, 0x17, 0xb2, 0x61, 0xed, 0xd5, 0x6b, 0xcc, 0x6d, 0x23, 0xe2, 0x3a, 0x89, 0x7b, 0xb4, + 0x4b, 0x5d, 0x26, 0xc6, 0x89, 0x90, 0x1e, 0x84, 0x90, 0x66, 0x23, 0x90, 0x42, 0x01, 0xda, 0x70, + 0xf9, 0x9f, 0x11, 0x2e, 0xf0, 0x44, 0xb8, 0x0f, 0xa3, 0x1d, 0x97, 0x3b, 0x2a, 0x62, 0xa0, 0x70, + 0x3f, 0x90, 0x6f, 0xf5, 0xb4, 0xf1, 0x18, 0x95, 0xf4, 0x27, 0xbf, 0xff, 0xfd, 0xe5, 0x60, 0x0a, + 0x27, 0xd4, 0x48, 0xd9, 0x87, 0x2d, 0xb8, 0xd2, 0x75, 0xdf, 0xe3, 0x6c, 0x64, 0x54, 0xa1, 0x4d, + 0xc8, 0xb7, 0x13, 0xac, 0x28, 0xfb, 0x24, 0xcf, 0x3e, 0x8e, 0xd7, 0xc4, 0xec, 0x8e, 0x51, 0xc7, + 0x1f, 0x25, 0x3a, 0x63, 0x11, 0x77, 0x3d, 0xaa, 0x91, 0x09, 0xe2, 0x1b, 0x8a, 0xfc, 0x46, 0xff, + 0x0e, 0x04, 0x37, 0xc7, 0xe1, 0x6e, 0xe2, 0x8c, 0x08, 0xe7, 0xb5, 0x22, 0xf5, 0xd0, 0xfb, 0x7b, + 0x84, 0xdf, 0x49, 0xf4, 0x71, 0x87, 0xee, 0x7e, 0x5c, 0xec, 0x23, 0x6b, 0xbb, 0xb1, 0xc8, 0xb9, + 0x7e, 0xcd, 0x09, 0xf1, 0x16, 0x47, 0x9c, 0xc6, 0xc9, 0x10, 0xa2, 0x6e, 0x57, 0xd5, 0x43, 0xf7, + 0xdf, 0x23, 0xfc, 0x18, 0x2e, 0x77, 0x0a, 0x0c, 0x8c, 0x3e, 0x17, 0xdd, 0xaa, 0x44, 0x9e, 0xed, + 0x6d, 0x44, 0xf9, 0x67, 0x78, 0xfe, 0x1b, 0x78, 0x5d, 0xcc, 0xbf, 0xcb, 0x98, 0x2b, 0x5c, 0xf0, + 0x5b, 0x89, 0x74, 0x84, 0xa0, 0x1e, 0x71, 0x21, 0x32, 0x7e, 0xf4, 0xaf, 0x06, 0xf9, 0x4e, 0x7f, + 0xc6, 0x04, 0x95, 0xe5, 0x50, 0x0a, 0x66, 0x44, 0x28, 0xdb, 0x73, 0x50, 0x03, 0xd5, 0x79, 0x2c, + 0x51, 0xa7, 0x8f, 0xd3, 0xb6, 0xb8, 0xd2, 0x4f, 0x66, 0xb1, 0x45, 0xc9, 0x77, 0xcf, 0xe8, 0x45, + 0xe0, 0x6b, 0x1c, 0x7c, 0x05, 0xf3, 0x49, 0xe0, 0x2a, 0x75, 0x3c, 0xf5, 0x90, 0x1e, 0x8e, 0xf0, + 0xd7, 0xe8, 0x1f, 0x5e, 0xbe, 0x7c, 0xc5, 0x7c, 0x1f, 0x48, 0x82, 0x4a, 0x96, 0x97, 0xcf, 0xe4, + 0x43, 0x45, 0xe4, 0x79, 0x11, 0x77, 0x70, 0x3e, 0xb1, 0x08, 0xe7, 0x40, 0x3d, 0x74, 0x95, 0xf7, + 0x11, 0x36, 0x00, 0xda, 0x52, 0x02, 0x6f, 0x46, 0xa6, 0xed, 0x54, 0x3d, 0xb2, 0xd2, 0xcb, 0x84, + 0x40, 0xa6, 0x39, 0xc8, 0x75, 0x1c, 0x17, 0x41, 0xb8, 0xe6, 0xc0, 0xaf, 0x25, 0x92, 0xcb, 0xdd, + 0xfa, 0x05, 0xe7, 0xe3, 0x43, 0x87, 0xf6, 0x79, 0xa1, 0x2f, 0xdb, 0xa4, 0xeb, 0x84, 0xf3, 0x74, + 0x6c, 0xe5, 0x6f, 0x12, 0x75, 0x97, 0x9e, 0x32, 0x06, 0xef, 0xc7, 0x26, 0x4f, 0x92, 0x50, 0xf2, + 0xda, 0xcb, 0xb8, 0x52, 0x19, 0x8b, 0xbc, 0x8c, 0x39, 0xbc, 0x9d, 0x50, 0x86, 0xea, 0x0a, 0x05, + 0x1b, 0x3f, 0x97, 0xe0, 0xff, 0x82, 0x50, 0xc0, 0xd7, 0x22, 0xd3, 0x87, 0x94, 0x91, 0x3c, 0x97, + 0x68, 0x97, 0xf4, 0xc5, 0x97, 0x9f, 0x05, 0xe7, 0x4d, 0x3d, 0x74, 0x4f, 0xda, 0x67, 0x12, 0xbc, + 0x22, 0xea, 0x16, 0x4c, 0xca, 0x13, 0xac, 0x5b, 0x36, 0xd9, 0x30, 0xe9, 0x62, 0xee, 0x20, 0xc2, + 0xaf, 0xfc, 0x23, 0xd8, 0x2d, 0x69, 0x62, 0x8e, 0x60, 0xa4, 0x2a, 0x8a, 0x39, 0x82, 0xd1, 0x1a, + 0x49, 0x99, 0xe5, 0x54, 0x69, 0x9c, 0xea, 0x41, 0x65, 0xe3, 0x2f, 0x12, 0xe9, 0xb0, 0x48, 0x75, + 0x83, 0x4b, 0x71, 0x8b, 0x10, 0x2b, 0x9f, 0xe4, 0xfc, 0x59, 0x5c, 0x88, 0x75, 0x99, 0xb3, 0x2e, + 0xe2, 0x42, 0x14, 0x6b, 0x29, 0xf0, 0xeb, 0xda, 0xde, 0xc2, 0xe6, 0xf1, 0x49, 0x5a, 0x7a, 0x71, + 0x92, 0x96, 0xfe, 0x3a, 0x49, 0x4b, 0x5f, 0x9c, 0xa6, 0x07, 0x5e, 0x9c, 0xa6, 0x07, 0xfe, 0x38, + 0x4d, 0x0f, 0x7c, 0x98, 0xab, 0x18, 0x4e, 0xb5, 0x59, 0xcc, 0x95, 0xac, 0x3d, 0x1e, 0x90, 0xff, + 0x77, 0x55, 0xc9, 0xaa, 0x79, 0xd1, 0x0f, 0x3a, 0xa5, 0x47, 0xab, 0xce, 0xec, 0xe2, 0x08, 0x37, + 0x58, 0xfe, 0x27, 0x00, 0x00, 0xff, 0xff, 0xc6, 0x84, 0xf6, 0xa8, 0x9a, 0x13, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1575,14 +1547,14 @@ type QueryClient interface { QueryBlockHeaderByHeight(ctx context.Context, in *QueryBlockHeaderByHeightRequest, opts ...grpc.CallOption) (*QueryBlockHeaderByHeightResponse, error) // BlockHeaderByHash queries the block header by hash. QueryBlockHeaderByHash(ctx context.Context, in *QueryBlockHeaderByHashRequest, opts ...grpc.CallOption) (*QueryBlockHeaderByHashResponse, error) + // QueryFeeRate queries the current bitcoin network fee rate on the side chain. + QueryFeeRate(ctx context.Context, in *QueryFeeRateRequest, opts ...grpc.CallOption) (*QueryFeeRateResponse, error) // QuerySigningRequests queries the signing requests by the given status. QuerySigningRequests(ctx context.Context, in *QuerySigningRequestsRequest, opts ...grpc.CallOption) (*QuerySigningRequestsResponse, error) // QuerySigningRequestsByAddress queries the signing requests by the given address. QuerySigningRequestsByAddress(ctx context.Context, in *QuerySigningRequestsByAddressRequest, opts ...grpc.CallOption) (*QuerySigningRequestsByAddressResponse, error) // QuerySigningRequestByTxHash queries the signing request by the given tx hash. QuerySigningRequestByTxHash(ctx context.Context, in *QuerySigningRequestByTxHashRequest, opts ...grpc.CallOption) (*QuerySigningRequestByTxHashResponse, error) - // QueryWithdrawNetworkFee queries the bitcoin network fee for withdrawal. - QueryWithdrawNetworkFee(ctx context.Context, in *QueryWithdrawNetworkFeeRequest, opts ...grpc.CallOption) (*QueryWithdrawNetworkFeeResponse, error) // QueryUTXOs queries all utxos. QueryUTXOs(ctx context.Context, in *QueryUTXOsRequest, opts ...grpc.CallOption) (*QueryUTXOsResponse, error) // QueryUTXOsByAddress queries the utxos of the given address. @@ -1643,6 +1615,15 @@ func (c *queryClient) QueryBlockHeaderByHash(ctx context.Context, in *QueryBlock return out, nil } +func (c *queryClient) QueryFeeRate(ctx context.Context, in *QueryFeeRateRequest, opts ...grpc.CallOption) (*QueryFeeRateResponse, error) { + out := new(QueryFeeRateResponse) + err := c.cc.Invoke(ctx, "/side.btcbridge.Query/QueryFeeRate", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryClient) QuerySigningRequests(ctx context.Context, in *QuerySigningRequestsRequest, opts ...grpc.CallOption) (*QuerySigningRequestsResponse, error) { out := new(QuerySigningRequestsResponse) err := c.cc.Invoke(ctx, "/side.btcbridge.Query/QuerySigningRequests", in, out, opts...) @@ -1670,15 +1651,6 @@ func (c *queryClient) QuerySigningRequestByTxHash(ctx context.Context, in *Query return out, nil } -func (c *queryClient) QueryWithdrawNetworkFee(ctx context.Context, in *QueryWithdrawNetworkFeeRequest, opts ...grpc.CallOption) (*QueryWithdrawNetworkFeeResponse, error) { - out := new(QueryWithdrawNetworkFeeResponse) - err := c.cc.Invoke(ctx, "/side.btcbridge.Query/QueryWithdrawNetworkFee", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - func (c *queryClient) QueryUTXOs(ctx context.Context, in *QueryUTXOsRequest, opts ...grpc.CallOption) (*QueryUTXOsResponse, error) { out := new(QueryUTXOsResponse) err := c.cc.Invoke(ctx, "/side.btcbridge.Query/QueryUTXOs", in, out, opts...) @@ -1752,14 +1724,14 @@ type QueryServer interface { QueryBlockHeaderByHeight(context.Context, *QueryBlockHeaderByHeightRequest) (*QueryBlockHeaderByHeightResponse, error) // BlockHeaderByHash queries the block header by hash. QueryBlockHeaderByHash(context.Context, *QueryBlockHeaderByHashRequest) (*QueryBlockHeaderByHashResponse, error) + // QueryFeeRate queries the current bitcoin network fee rate on the side chain. + QueryFeeRate(context.Context, *QueryFeeRateRequest) (*QueryFeeRateResponse, error) // QuerySigningRequests queries the signing requests by the given status. QuerySigningRequests(context.Context, *QuerySigningRequestsRequest) (*QuerySigningRequestsResponse, error) // QuerySigningRequestsByAddress queries the signing requests by the given address. QuerySigningRequestsByAddress(context.Context, *QuerySigningRequestsByAddressRequest) (*QuerySigningRequestsByAddressResponse, error) // QuerySigningRequestByTxHash queries the signing request by the given tx hash. QuerySigningRequestByTxHash(context.Context, *QuerySigningRequestByTxHashRequest) (*QuerySigningRequestByTxHashResponse, error) - // QueryWithdrawNetworkFee queries the bitcoin network fee for withdrawal. - QueryWithdrawNetworkFee(context.Context, *QueryWithdrawNetworkFeeRequest) (*QueryWithdrawNetworkFeeResponse, error) // QueryUTXOs queries all utxos. QueryUTXOs(context.Context, *QueryUTXOsRequest) (*QueryUTXOsResponse, error) // QueryUTXOsByAddress queries the utxos of the given address. @@ -1792,6 +1764,9 @@ func (*UnimplementedQueryServer) QueryBlockHeaderByHeight(ctx context.Context, r func (*UnimplementedQueryServer) QueryBlockHeaderByHash(ctx context.Context, req *QueryBlockHeaderByHashRequest) (*QueryBlockHeaderByHashResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method QueryBlockHeaderByHash not implemented") } +func (*UnimplementedQueryServer) QueryFeeRate(ctx context.Context, req *QueryFeeRateRequest) (*QueryFeeRateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method QueryFeeRate not implemented") +} func (*UnimplementedQueryServer) QuerySigningRequests(ctx context.Context, req *QuerySigningRequestsRequest) (*QuerySigningRequestsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method QuerySigningRequests not implemented") } @@ -1801,9 +1776,6 @@ func (*UnimplementedQueryServer) QuerySigningRequestsByAddress(ctx context.Conte func (*UnimplementedQueryServer) QuerySigningRequestByTxHash(ctx context.Context, req *QuerySigningRequestByTxHashRequest) (*QuerySigningRequestByTxHashResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method QuerySigningRequestByTxHash not implemented") } -func (*UnimplementedQueryServer) QueryWithdrawNetworkFee(ctx context.Context, req *QueryWithdrawNetworkFeeRequest) (*QueryWithdrawNetworkFeeResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method QueryWithdrawNetworkFee not implemented") -} func (*UnimplementedQueryServer) QueryUTXOs(ctx context.Context, req *QueryUTXOsRequest) (*QueryUTXOsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method QueryUTXOs not implemented") } @@ -1902,6 +1874,24 @@ func _Query_QueryBlockHeaderByHash_Handler(srv interface{}, ctx context.Context, return interceptor(ctx, in, info, handler) } +func _Query_QueryFeeRate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryFeeRateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).QueryFeeRate(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/side.btcbridge.Query/QueryFeeRate", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).QueryFeeRate(ctx, req.(*QueryFeeRateRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Query_QuerySigningRequests_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QuerySigningRequestsRequest) if err := dec(in); err != nil { @@ -1956,24 +1946,6 @@ func _Query_QuerySigningRequestByTxHash_Handler(srv interface{}, ctx context.Con return interceptor(ctx, in, info, handler) } -func _Query_QueryWithdrawNetworkFee_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(QueryWithdrawNetworkFeeRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(QueryServer).QueryWithdrawNetworkFee(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/side.btcbridge.Query/QueryWithdrawNetworkFee", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(QueryServer).QueryWithdrawNetworkFee(ctx, req.(*QueryWithdrawNetworkFeeRequest)) - } - return interceptor(ctx, in, info, handler) -} - func _Query_QueryUTXOs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryUTXOsRequest) if err := dec(in); err != nil { @@ -2120,6 +2092,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{ MethodName: "QueryBlockHeaderByHash", Handler: _Query_QueryBlockHeaderByHash_Handler, }, + { + MethodName: "QueryFeeRate", + Handler: _Query_QueryFeeRate_Handler, + }, { MethodName: "QuerySigningRequests", Handler: _Query_QuerySigningRequests_Handler, @@ -2132,10 +2108,6 @@ var _Query_serviceDesc = grpc.ServiceDesc{ MethodName: "QuerySigningRequestByTxHash", Handler: _Query_QuerySigningRequestByTxHash_Handler, }, - { - MethodName: "QueryWithdrawNetworkFee", - Handler: _Query_QueryWithdrawNetworkFee_Handler, - }, { MethodName: "QueryUTXOs", Handler: _Query_QueryUTXOs_Handler, @@ -2414,7 +2386,7 @@ func (m *QuerySigningRequestByTxHashResponse) MarshalToSizedBuffer(dAtA []byte) return len(dAtA) - i, nil } -func (m *QueryWithdrawNetworkFeeRequest) Marshal() (dAtA []byte, err error) { +func (m *QueryFeeRateRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2424,41 +2396,20 @@ func (m *QueryWithdrawNetworkFeeRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *QueryWithdrawNetworkFeeRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *QueryFeeRateRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *QueryWithdrawNetworkFeeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *QueryFeeRateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.FeeRate) > 0 { - i -= len(m.FeeRate) - copy(dAtA[i:], m.FeeRate) - i = encodeVarintQuery(dAtA, i, uint64(len(m.FeeRate))) - i-- - dAtA[i] = 0x1a - } - if len(m.Amount) > 0 { - i -= len(m.Amount) - copy(dAtA[i:], m.Amount) - i = encodeVarintQuery(dAtA, i, uint64(len(m.Amount))) - i-- - dAtA[i] = 0x12 - } - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintQuery(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa - } return len(dAtA) - i, nil } -func (m *QueryWithdrawNetworkFeeResponse) Marshal() (dAtA []byte, err error) { +func (m *QueryFeeRateResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2468,18 +2419,18 @@ func (m *QueryWithdrawNetworkFeeResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *QueryWithdrawNetworkFeeResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *QueryFeeRateResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *QueryWithdrawNetworkFeeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *QueryFeeRateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Fee != 0 { - i = encodeVarintQuery(dAtA, i, uint64(m.Fee)) + if m.FeeRate != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.FeeRate)) i-- dAtA[i] = 0x8 } @@ -3293,35 +3244,23 @@ func (m *QuerySigningRequestByTxHashResponse) Size() (n int) { return n } -func (m *QueryWithdrawNetworkFeeRequest) Size() (n int) { +func (m *QueryFeeRateRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovQuery(uint64(l)) - } - l = len(m.Amount) - if l > 0 { - n += 1 + l + sovQuery(uint64(l)) - } - l = len(m.FeeRate) - if l > 0 { - n += 1 + l + sovQuery(uint64(l)) - } return n } -func (m *QueryWithdrawNetworkFeeResponse) Size() (n int) { +func (m *QueryFeeRateResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Fee != 0 { - n += 1 + sovQuery(uint64(m.Fee)) + if m.FeeRate != 0 { + n += 1 + sovQuery(uint64(m.FeeRate)) } return n } @@ -4248,7 +4187,7 @@ func (m *QuerySigningRequestByTxHashResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *QueryWithdrawNetworkFeeRequest) Unmarshal(dAtA []byte) error { +func (m *QueryFeeRateRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4271,108 +4210,12 @@ func (m *QueryWithdrawNetworkFeeRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: QueryWithdrawNetworkFeeRequest: wiretype end group for non-group") + return fmt.Errorf("proto: QueryFeeRateRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: QueryWithdrawNetworkFeeRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: QueryFeeRateRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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 - } - m.Sender = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Amount", 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 - } - m.Amount = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FeeRate", 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 - } - m.FeeRate = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipQuery(dAtA[iNdEx:]) @@ -4394,7 +4237,7 @@ func (m *QueryWithdrawNetworkFeeRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *QueryWithdrawNetworkFeeResponse) Unmarshal(dAtA []byte) error { +func (m *QueryFeeRateResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4417,17 +4260,17 @@ func (m *QueryWithdrawNetworkFeeResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: QueryWithdrawNetworkFeeResponse: wiretype end group for non-group") + return fmt.Errorf("proto: QueryFeeRateResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: QueryWithdrawNetworkFeeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: QueryFeeRateResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field FeeRate", wireType) } - m.Fee = 0 + m.FeeRate = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowQuery @@ -4437,7 +4280,7 @@ func (m *QueryWithdrawNetworkFeeResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Fee |= int64(b&0x7F) << shift + m.FeeRate |= int64(b&0x7F) << shift if b < 0x80 { break } diff --git a/x/btcbridge/types/query.pb.gw.go b/x/btcbridge/types/query.pb.gw.go index 0a004582..a2951554 100644 --- a/x/btcbridge/types/query.pb.gw.go +++ b/x/btcbridge/types/query.pb.gw.go @@ -177,6 +177,24 @@ func local_request_Query_QueryBlockHeaderByHash_0(ctx context.Context, marshaler } +func request_Query_QueryFeeRate_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryFeeRateRequest + var metadata runtime.ServerMetadata + + msg, err := client.QueryFeeRate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_QueryFeeRate_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryFeeRateRequest + var metadata runtime.ServerMetadata + + msg, err := server.QueryFeeRate(ctx, &protoReq) + return msg, metadata, err + +} + var ( filter_Query_QuerySigningRequests_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} ) @@ -339,42 +357,6 @@ func local_request_Query_QuerySigningRequestByTxHash_0(ctx context.Context, mars } -var ( - filter_Query_QueryWithdrawNetworkFee_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} -) - -func request_Query_QueryWithdrawNetworkFee_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryWithdrawNetworkFeeRequest - var metadata runtime.ServerMetadata - - if err := req.ParseForm(); err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_QueryWithdrawNetworkFee_0); err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - - msg, err := client.QueryWithdrawNetworkFee(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) - return msg, metadata, err - -} - -func local_request_Query_QueryWithdrawNetworkFee_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryWithdrawNetworkFeeRequest - var metadata runtime.ServerMetadata - - if err := req.ParseForm(); err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_QueryWithdrawNetworkFee_0); err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - - msg, err := server.QueryWithdrawNetworkFee(ctx, &protoReq) - return msg, metadata, err - -} - func request_Query_QueryUTXOs_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryUTXOsRequest var metadata runtime.ServerMetadata @@ -761,7 +743,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) - mux.Handle("GET", pattern_Query_QuerySigningRequests_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QueryFeeRate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() var stream runtime.ServerTransportStream @@ -772,7 +754,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := local_request_Query_QuerySigningRequests_0(rctx, inboundMarshaler, server, req, pathParams) + resp, md, err := local_request_Query_QueryFeeRate_0(rctx, inboundMarshaler, server, req, pathParams) md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { @@ -780,11 +762,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv return } - forward_Query_QuerySigningRequests_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QueryFeeRate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_QuerySigningRequestsByAddress_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QuerySigningRequests_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() var stream runtime.ServerTransportStream @@ -795,7 +777,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := local_request_Query_QuerySigningRequestsByAddress_0(rctx, inboundMarshaler, server, req, pathParams) + resp, md, err := local_request_Query_QuerySigningRequests_0(rctx, inboundMarshaler, server, req, pathParams) md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { @@ -803,11 +785,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv return } - forward_Query_QuerySigningRequestsByAddress_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QuerySigningRequests_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_QuerySigningRequestByTxHash_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QuerySigningRequestsByAddress_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() var stream runtime.ServerTransportStream @@ -818,7 +800,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := local_request_Query_QuerySigningRequestByTxHash_0(rctx, inboundMarshaler, server, req, pathParams) + resp, md, err := local_request_Query_QuerySigningRequestsByAddress_0(rctx, inboundMarshaler, server, req, pathParams) md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { @@ -826,11 +808,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv return } - forward_Query_QuerySigningRequestByTxHash_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QuerySigningRequestsByAddress_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_QueryWithdrawNetworkFee_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QuerySigningRequestByTxHash_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() var stream runtime.ServerTransportStream @@ -841,7 +823,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := local_request_Query_QueryWithdrawNetworkFee_0(rctx, inboundMarshaler, server, req, pathParams) + resp, md, err := local_request_Query_QuerySigningRequestByTxHash_0(rctx, inboundMarshaler, server, req, pathParams) md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { @@ -849,7 +831,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv return } - forward_Query_QueryWithdrawNetworkFee_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QuerySigningRequestByTxHash_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) @@ -1135,7 +1117,7 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) - mux.Handle("GET", pattern_Query_QuerySigningRequests_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QueryFeeRate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) @@ -1144,18 +1126,18 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := request_Query_QuerySigningRequests_0(rctx, inboundMarshaler, client, req, pathParams) + resp, md, err := request_Query_QueryFeeRate_0(rctx, inboundMarshaler, client, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - forward_Query_QuerySigningRequests_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QueryFeeRate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_QuerySigningRequestsByAddress_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QuerySigningRequests_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) @@ -1164,18 +1146,18 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := request_Query_QuerySigningRequestsByAddress_0(rctx, inboundMarshaler, client, req, pathParams) + resp, md, err := request_Query_QuerySigningRequests_0(rctx, inboundMarshaler, client, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - forward_Query_QuerySigningRequestsByAddress_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QuerySigningRequests_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_QuerySigningRequestByTxHash_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QuerySigningRequestsByAddress_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) @@ -1184,18 +1166,18 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := request_Query_QuerySigningRequestByTxHash_0(rctx, inboundMarshaler, client, req, pathParams) + resp, md, err := request_Query_QuerySigningRequestsByAddress_0(rctx, inboundMarshaler, client, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - forward_Query_QuerySigningRequestByTxHash_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QuerySigningRequestsByAddress_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("GET", pattern_Query_QueryWithdrawNetworkFee_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_QuerySigningRequestByTxHash_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) @@ -1204,14 +1186,14 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := request_Query_QueryWithdrawNetworkFee_0(rctx, inboundMarshaler, client, req, pathParams) + resp, md, err := request_Query_QuerySigningRequestByTxHash_0(rctx, inboundMarshaler, client, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - forward_Query_QueryWithdrawNetworkFee_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_QuerySigningRequestByTxHash_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) @@ -1367,14 +1349,14 @@ var ( pattern_Query_QueryBlockHeaderByHash_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 2}, []string{"side", "btcbridge", "hash"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_QueryFeeRate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"side", "btcbridge", "feerate"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_QuerySigningRequests_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"side", "btcbridge", "signing", "requests"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_QuerySigningRequestsByAddress_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 4}, []string{"side", "btcbridge", "signing", "requests", "address"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_QuerySigningRequestByTxHash_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"side", "btcbridge", "signing", "requests", "tx", "txid"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_QueryWithdrawNetworkFee_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"side", "btcbridge", "withdrawal", "fee"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_QueryUTXOs_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"side", "btcbridge", "utxos"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_QueryUTXOsByAddress_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"side", "btcbridge", "utxos", "address"}, "", runtime.AssumeColonVerbOpt(true))) @@ -1399,14 +1381,14 @@ var ( forward_Query_QueryBlockHeaderByHash_0 = runtime.ForwardResponseMessage + forward_Query_QueryFeeRate_0 = runtime.ForwardResponseMessage + forward_Query_QuerySigningRequests_0 = runtime.ForwardResponseMessage forward_Query_QuerySigningRequestsByAddress_0 = runtime.ForwardResponseMessage forward_Query_QuerySigningRequestByTxHash_0 = runtime.ForwardResponseMessage - forward_Query_QueryWithdrawNetworkFee_0 = runtime.ForwardResponseMessage - forward_Query_QueryUTXOs_0 = runtime.ForwardResponseMessage forward_Query_QueryUTXOsByAddress_0 = runtime.ForwardResponseMessage diff --git a/x/btcbridge/types/tx.pb.go b/x/btcbridge/types/tx.pb.go index ef2c63cb..49f332bd 100644 --- a/x/btcbridge/types/tx.pb.go +++ b/x/btcbridge/types/tx.pb.go @@ -118,96 +118,6 @@ func (m *MsgSubmitBlockHeadersResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgSubmitBlockHeadersResponse proto.InternalMessageInfo -// MsgUpdateNonBtcRelayers defines the Msg/UpdateNonBtcRelayers request type. -type MsgUpdateNonBtcRelayers struct { - Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` - Relayers []string `protobuf:"bytes,2,rep,name=relayers,proto3" json:"relayers,omitempty"` -} - -func (m *MsgUpdateNonBtcRelayers) Reset() { *m = MsgUpdateNonBtcRelayers{} } -func (m *MsgUpdateNonBtcRelayers) String() string { return proto.CompactTextString(m) } -func (*MsgUpdateNonBtcRelayers) ProtoMessage() {} -func (*MsgUpdateNonBtcRelayers) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{2} -} -func (m *MsgUpdateNonBtcRelayers) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MsgUpdateNonBtcRelayers) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MsgUpdateNonBtcRelayers.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 *MsgUpdateNonBtcRelayers) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgUpdateNonBtcRelayers.Merge(m, src) -} -func (m *MsgUpdateNonBtcRelayers) XXX_Size() int { - return m.Size() -} -func (m *MsgUpdateNonBtcRelayers) XXX_DiscardUnknown() { - xxx_messageInfo_MsgUpdateNonBtcRelayers.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgUpdateNonBtcRelayers proto.InternalMessageInfo - -func (m *MsgUpdateNonBtcRelayers) GetSender() string { - if m != nil { - return m.Sender - } - return "" -} - -func (m *MsgUpdateNonBtcRelayers) GetRelayers() []string { - if m != nil { - return m.Relayers - } - return nil -} - -// MsgUpdateNonBtcRelayersResponse defines the Msg/UpdateNonBtcRelayers response type. -type MsgUpdateNonBtcRelayersResponse struct { -} - -func (m *MsgUpdateNonBtcRelayersResponse) Reset() { *m = MsgUpdateNonBtcRelayersResponse{} } -func (m *MsgUpdateNonBtcRelayersResponse) String() string { return proto.CompactTextString(m) } -func (*MsgUpdateNonBtcRelayersResponse) ProtoMessage() {} -func (*MsgUpdateNonBtcRelayersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{3} -} -func (m *MsgUpdateNonBtcRelayersResponse) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MsgUpdateNonBtcRelayersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MsgUpdateNonBtcRelayersResponse.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 *MsgUpdateNonBtcRelayersResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgUpdateNonBtcRelayersResponse.Merge(m, src) -} -func (m *MsgUpdateNonBtcRelayersResponse) XXX_Size() int { - return m.Size() -} -func (m *MsgUpdateNonBtcRelayersResponse) XXX_DiscardUnknown() { - xxx_messageInfo_MsgUpdateNonBtcRelayersResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgUpdateNonBtcRelayersResponse proto.InternalMessageInfo - // MsgSubmitDepositTransaction defines the Msg/SubmitDepositTransaction request type. type MsgSubmitDepositTransaction struct { // this is the relayer address who submits the bitcoin transaction to the side chain @@ -225,7 +135,7 @@ func (m *MsgSubmitDepositTransaction) Reset() { *m = MsgSubmitDepositTra func (m *MsgSubmitDepositTransaction) String() string { return proto.CompactTextString(m) } func (*MsgSubmitDepositTransaction) ProtoMessage() {} func (*MsgSubmitDepositTransaction) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{4} + return fileDescriptor_785ca8e1e4227068, []int{2} } func (m *MsgSubmitDepositTransaction) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -297,7 +207,7 @@ func (m *MsgSubmitDepositTransactionResponse) Reset() { *m = MsgSubmitDe func (m *MsgSubmitDepositTransactionResponse) String() string { return proto.CompactTextString(m) } func (*MsgSubmitDepositTransactionResponse) ProtoMessage() {} func (*MsgSubmitDepositTransactionResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{5} + return fileDescriptor_785ca8e1e4227068, []int{3} } func (m *MsgSubmitDepositTransactionResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -340,7 +250,7 @@ func (m *MsgSubmitWithdrawTransaction) Reset() { *m = MsgSubmitWithdrawT func (m *MsgSubmitWithdrawTransaction) String() string { return proto.CompactTextString(m) } func (*MsgSubmitWithdrawTransaction) ProtoMessage() {} func (*MsgSubmitWithdrawTransaction) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{6} + return fileDescriptor_785ca8e1e4227068, []int{4} } func (m *MsgSubmitWithdrawTransaction) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -405,7 +315,7 @@ func (m *MsgSubmitWithdrawTransactionResponse) Reset() { *m = MsgSubmitW func (m *MsgSubmitWithdrawTransactionResponse) String() string { return proto.CompactTextString(m) } func (*MsgSubmitWithdrawTransactionResponse) ProtoMessage() {} func (*MsgSubmitWithdrawTransactionResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{7} + return fileDescriptor_785ca8e1e4227068, []int{5} } func (m *MsgSubmitWithdrawTransactionResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -434,20 +344,290 @@ func (m *MsgSubmitWithdrawTransactionResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgSubmitWithdrawTransactionResponse proto.InternalMessageInfo +// MsgSubmitFeeRate defines the Msg/SubmitFeeRate request type. +type MsgSubmitFeeRate struct { + Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` + FeeRate int64 `protobuf:"varint,2,opt,name=fee_rate,json=feeRate,proto3" json:"fee_rate,omitempty"` +} + +func (m *MsgSubmitFeeRate) Reset() { *m = MsgSubmitFeeRate{} } +func (m *MsgSubmitFeeRate) String() string { return proto.CompactTextString(m) } +func (*MsgSubmitFeeRate) ProtoMessage() {} +func (*MsgSubmitFeeRate) Descriptor() ([]byte, []int) { + return fileDescriptor_785ca8e1e4227068, []int{6} +} +func (m *MsgSubmitFeeRate) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgSubmitFeeRate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgSubmitFeeRate.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 *MsgSubmitFeeRate) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgSubmitFeeRate.Merge(m, src) +} +func (m *MsgSubmitFeeRate) XXX_Size() int { + return m.Size() +} +func (m *MsgSubmitFeeRate) XXX_DiscardUnknown() { + xxx_messageInfo_MsgSubmitFeeRate.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgSubmitFeeRate proto.InternalMessageInfo + +func (m *MsgSubmitFeeRate) GetSender() string { + if m != nil { + return m.Sender + } + return "" +} + +func (m *MsgSubmitFeeRate) GetFeeRate() int64 { + if m != nil { + return m.FeeRate + } + return 0 +} + +// MsgSubmitFeeRateResponse defines the Msg/SubmitFeeRate response type. +type MsgSubmitFeeRateResponse struct { +} + +func (m *MsgSubmitFeeRateResponse) Reset() { *m = MsgSubmitFeeRateResponse{} } +func (m *MsgSubmitFeeRateResponse) String() string { return proto.CompactTextString(m) } +func (*MsgSubmitFeeRateResponse) ProtoMessage() {} +func (*MsgSubmitFeeRateResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_785ca8e1e4227068, []int{7} +} +func (m *MsgSubmitFeeRateResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgSubmitFeeRateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgSubmitFeeRateResponse.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 *MsgSubmitFeeRateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgSubmitFeeRateResponse.Merge(m, src) +} +func (m *MsgSubmitFeeRateResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgSubmitFeeRateResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgSubmitFeeRateResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgSubmitFeeRateResponse proto.InternalMessageInfo + +// MsgUpdateTrustedNonBtcRelayers defines the Msg/UpdateTrustedNonBtcRelayers request type. +type MsgUpdateTrustedNonBtcRelayers struct { + Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` + Relayers []string `protobuf:"bytes,2,rep,name=relayers,proto3" json:"relayers,omitempty"` +} + +func (m *MsgUpdateTrustedNonBtcRelayers) Reset() { *m = MsgUpdateTrustedNonBtcRelayers{} } +func (m *MsgUpdateTrustedNonBtcRelayers) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateTrustedNonBtcRelayers) ProtoMessage() {} +func (*MsgUpdateTrustedNonBtcRelayers) Descriptor() ([]byte, []int) { + return fileDescriptor_785ca8e1e4227068, []int{8} +} +func (m *MsgUpdateTrustedNonBtcRelayers) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateTrustedNonBtcRelayers) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateTrustedNonBtcRelayers.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 *MsgUpdateTrustedNonBtcRelayers) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateTrustedNonBtcRelayers.Merge(m, src) +} +func (m *MsgUpdateTrustedNonBtcRelayers) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateTrustedNonBtcRelayers) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateTrustedNonBtcRelayers.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateTrustedNonBtcRelayers proto.InternalMessageInfo + +func (m *MsgUpdateTrustedNonBtcRelayers) GetSender() string { + if m != nil { + return m.Sender + } + return "" +} + +func (m *MsgUpdateTrustedNonBtcRelayers) GetRelayers() []string { + if m != nil { + return m.Relayers + } + return nil +} + +// MsgUpdateTrustedNonBtcRelayersResponse defines the Msg/UpdateTrustedNonBtcRelayers response type. +type MsgUpdateTrustedNonBtcRelayersResponse struct { +} + +func (m *MsgUpdateTrustedNonBtcRelayersResponse) Reset() { + *m = MsgUpdateTrustedNonBtcRelayersResponse{} +} +func (m *MsgUpdateTrustedNonBtcRelayersResponse) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateTrustedNonBtcRelayersResponse) ProtoMessage() {} +func (*MsgUpdateTrustedNonBtcRelayersResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_785ca8e1e4227068, []int{9} +} +func (m *MsgUpdateTrustedNonBtcRelayersResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateTrustedNonBtcRelayersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateTrustedNonBtcRelayersResponse.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 *MsgUpdateTrustedNonBtcRelayersResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateTrustedNonBtcRelayersResponse.Merge(m, src) +} +func (m *MsgUpdateTrustedNonBtcRelayersResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateTrustedNonBtcRelayersResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateTrustedNonBtcRelayersResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateTrustedNonBtcRelayersResponse proto.InternalMessageInfo + +// MsgUpdateTrustedOracles defines the Msg/UpdateTrustedOracles request type. +type MsgUpdateTrustedOracles struct { + Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` + Oracles []string `protobuf:"bytes,2,rep,name=oracles,proto3" json:"oracles,omitempty"` +} + +func (m *MsgUpdateTrustedOracles) Reset() { *m = MsgUpdateTrustedOracles{} } +func (m *MsgUpdateTrustedOracles) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateTrustedOracles) ProtoMessage() {} +func (*MsgUpdateTrustedOracles) Descriptor() ([]byte, []int) { + return fileDescriptor_785ca8e1e4227068, []int{10} +} +func (m *MsgUpdateTrustedOracles) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateTrustedOracles) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateTrustedOracles.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 *MsgUpdateTrustedOracles) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateTrustedOracles.Merge(m, src) +} +func (m *MsgUpdateTrustedOracles) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateTrustedOracles) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateTrustedOracles.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateTrustedOracles proto.InternalMessageInfo + +func (m *MsgUpdateTrustedOracles) GetSender() string { + if m != nil { + return m.Sender + } + return "" +} + +func (m *MsgUpdateTrustedOracles) GetOracles() []string { + if m != nil { + return m.Oracles + } + return nil +} + +// MsgUpdateTrustedOraclesResponse defines the Msg/UpdateTrustedOracles response type. +type MsgUpdateTrustedOraclesResponse struct { +} + +func (m *MsgUpdateTrustedOraclesResponse) Reset() { *m = MsgUpdateTrustedOraclesResponse{} } +func (m *MsgUpdateTrustedOraclesResponse) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateTrustedOraclesResponse) ProtoMessage() {} +func (*MsgUpdateTrustedOraclesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_785ca8e1e4227068, []int{11} +} +func (m *MsgUpdateTrustedOraclesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateTrustedOraclesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateTrustedOraclesResponse.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 *MsgUpdateTrustedOraclesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateTrustedOraclesResponse.Merge(m, src) +} +func (m *MsgUpdateTrustedOraclesResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateTrustedOraclesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateTrustedOraclesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateTrustedOraclesResponse proto.InternalMessageInfo + // MsgWithdrawToBitcoin defines the Msg/WithdrawToBitcoin request type. type MsgWithdrawToBitcoin struct { Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` // withdraw amount in satoshi, etc: 100000000sat = 1btc Amount string `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"` - // fee rate in sats/vB - FeeRate string `protobuf:"bytes,3,opt,name=fee_rate,json=feeRate,proto3" json:"fee_rate,omitempty"` } func (m *MsgWithdrawToBitcoin) Reset() { *m = MsgWithdrawToBitcoin{} } func (m *MsgWithdrawToBitcoin) String() string { return proto.CompactTextString(m) } func (*MsgWithdrawToBitcoin) ProtoMessage() {} func (*MsgWithdrawToBitcoin) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{8} + return fileDescriptor_785ca8e1e4227068, []int{12} } func (m *MsgWithdrawToBitcoin) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -490,13 +670,6 @@ func (m *MsgWithdrawToBitcoin) GetAmount() string { return "" } -func (m *MsgWithdrawToBitcoin) GetFeeRate() string { - if m != nil { - return m.FeeRate - } - return "" -} - // MsgWithdrawToBitcoinResponse defines the Msg/WithdrawToBitcoin response type. type MsgWithdrawToBitcoinResponse struct { } @@ -505,7 +678,7 @@ func (m *MsgWithdrawToBitcoinResponse) Reset() { *m = MsgWithdrawToBitco func (m *MsgWithdrawToBitcoinResponse) String() string { return proto.CompactTextString(m) } func (*MsgWithdrawToBitcoinResponse) ProtoMessage() {} func (*MsgWithdrawToBitcoinResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{9} + return fileDescriptor_785ca8e1e4227068, []int{13} } func (m *MsgWithdrawToBitcoinResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -545,7 +718,7 @@ func (m *MsgSubmitSignatures) Reset() { *m = MsgSubmitSignatures{} } func (m *MsgSubmitSignatures) String() string { return proto.CompactTextString(m) } func (*MsgSubmitSignatures) ProtoMessage() {} func (*MsgSubmitSignatures) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{10} + return fileDescriptor_785ca8e1e4227068, []int{14} } func (m *MsgSubmitSignatures) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -603,7 +776,7 @@ func (m *MsgSubmitSignaturesResponse) Reset() { *m = MsgSubmitSignatures func (m *MsgSubmitSignaturesResponse) String() string { return proto.CompactTextString(m) } func (*MsgSubmitSignaturesResponse) ProtoMessage() {} func (*MsgSubmitSignaturesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{11} + return fileDescriptor_785ca8e1e4227068, []int{15} } func (m *MsgSubmitSignaturesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -650,7 +823,7 @@ func (m *MsgConsolidateVaults) Reset() { *m = MsgConsolidateVaults{} } func (m *MsgConsolidateVaults) String() string { return proto.CompactTextString(m) } func (*MsgConsolidateVaults) ProtoMessage() {} func (*MsgConsolidateVaults) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{12} + return fileDescriptor_785ca8e1e4227068, []int{16} } func (m *MsgConsolidateVaults) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -722,7 +895,7 @@ func (m *MsgConsolidateVaultsResponse) Reset() { *m = MsgConsolidateVaul func (m *MsgConsolidateVaultsResponse) String() string { return proto.CompactTextString(m) } func (*MsgConsolidateVaultsResponse) ProtoMessage() {} func (*MsgConsolidateVaultsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{13} + return fileDescriptor_785ca8e1e4227068, []int{17} } func (m *MsgConsolidateVaultsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -775,7 +948,7 @@ func (m *MsgInitiateDKG) Reset() { *m = MsgInitiateDKG{} } func (m *MsgInitiateDKG) String() string { return proto.CompactTextString(m) } func (*MsgInitiateDKG) ProtoMessage() {} func (*MsgInitiateDKG) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{14} + return fileDescriptor_785ca8e1e4227068, []int{18} } func (m *MsgInitiateDKG) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -868,7 +1041,7 @@ func (m *MsgInitiateDKGResponse) Reset() { *m = MsgInitiateDKGResponse{} func (m *MsgInitiateDKGResponse) String() string { return proto.CompactTextString(m) } func (*MsgInitiateDKGResponse) ProtoMessage() {} func (*MsgInitiateDKGResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{15} + return fileDescriptor_785ca8e1e4227068, []int{19} } func (m *MsgInitiateDKGResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -915,7 +1088,7 @@ func (m *MsgCompleteDKG) Reset() { *m = MsgCompleteDKG{} } func (m *MsgCompleteDKG) String() string { return proto.CompactTextString(m) } func (*MsgCompleteDKG) ProtoMessage() {} func (*MsgCompleteDKG) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{16} + return fileDescriptor_785ca8e1e4227068, []int{20} } func (m *MsgCompleteDKG) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -987,7 +1160,7 @@ func (m *MsgCompleteDKGResponse) Reset() { *m = MsgCompleteDKGResponse{} func (m *MsgCompleteDKGResponse) String() string { return proto.CompactTextString(m) } func (*MsgCompleteDKGResponse) ProtoMessage() {} func (*MsgCompleteDKGResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{17} + return fileDescriptor_785ca8e1e4227068, []int{21} } func (m *MsgCompleteDKGResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1038,7 +1211,7 @@ func (m *MsgTransferVault) Reset() { *m = MsgTransferVault{} } func (m *MsgTransferVault) String() string { return proto.CompactTextString(m) } func (*MsgTransferVault) ProtoMessage() {} func (*MsgTransferVault) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{18} + return fileDescriptor_785ca8e1e4227068, []int{22} } func (m *MsgTransferVault) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1124,7 +1297,7 @@ func (m *MsgTransferVaultResponse) Reset() { *m = MsgTransferVaultRespon func (m *MsgTransferVaultResponse) String() string { return proto.CompactTextString(m) } func (*MsgTransferVaultResponse) ProtoMessage() {} func (*MsgTransferVaultResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{19} + return fileDescriptor_785ca8e1e4227068, []int{23} } func (m *MsgTransferVaultResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1169,7 +1342,7 @@ func (m *MsgUpdateParams) Reset() { *m = MsgUpdateParams{} } func (m *MsgUpdateParams) String() string { return proto.CompactTextString(m) } func (*MsgUpdateParams) ProtoMessage() {} func (*MsgUpdateParams) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{20} + return fileDescriptor_785ca8e1e4227068, []int{24} } func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1222,7 +1395,7 @@ func (m *MsgUpdateParamsResponse) Reset() { *m = MsgUpdateParamsResponse func (m *MsgUpdateParamsResponse) String() string { return proto.CompactTextString(m) } func (*MsgUpdateParamsResponse) ProtoMessage() {} func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_785ca8e1e4227068, []int{21} + return fileDescriptor_785ca8e1e4227068, []int{25} } func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1254,12 +1427,16 @@ var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo func init() { proto.RegisterType((*MsgSubmitBlockHeaders)(nil), "side.btcbridge.MsgSubmitBlockHeaders") proto.RegisterType((*MsgSubmitBlockHeadersResponse)(nil), "side.btcbridge.MsgSubmitBlockHeadersResponse") - proto.RegisterType((*MsgUpdateNonBtcRelayers)(nil), "side.btcbridge.MsgUpdateNonBtcRelayers") - proto.RegisterType((*MsgUpdateNonBtcRelayersResponse)(nil), "side.btcbridge.MsgUpdateNonBtcRelayersResponse") proto.RegisterType((*MsgSubmitDepositTransaction)(nil), "side.btcbridge.MsgSubmitDepositTransaction") proto.RegisterType((*MsgSubmitDepositTransactionResponse)(nil), "side.btcbridge.MsgSubmitDepositTransactionResponse") proto.RegisterType((*MsgSubmitWithdrawTransaction)(nil), "side.btcbridge.MsgSubmitWithdrawTransaction") proto.RegisterType((*MsgSubmitWithdrawTransactionResponse)(nil), "side.btcbridge.MsgSubmitWithdrawTransactionResponse") + proto.RegisterType((*MsgSubmitFeeRate)(nil), "side.btcbridge.MsgSubmitFeeRate") + proto.RegisterType((*MsgSubmitFeeRateResponse)(nil), "side.btcbridge.MsgSubmitFeeRateResponse") + proto.RegisterType((*MsgUpdateTrustedNonBtcRelayers)(nil), "side.btcbridge.MsgUpdateTrustedNonBtcRelayers") + proto.RegisterType((*MsgUpdateTrustedNonBtcRelayersResponse)(nil), "side.btcbridge.MsgUpdateTrustedNonBtcRelayersResponse") + proto.RegisterType((*MsgUpdateTrustedOracles)(nil), "side.btcbridge.MsgUpdateTrustedOracles") + proto.RegisterType((*MsgUpdateTrustedOraclesResponse)(nil), "side.btcbridge.MsgUpdateTrustedOraclesResponse") proto.RegisterType((*MsgWithdrawToBitcoin)(nil), "side.btcbridge.MsgWithdrawToBitcoin") proto.RegisterType((*MsgWithdrawToBitcoinResponse)(nil), "side.btcbridge.MsgWithdrawToBitcoinResponse") proto.RegisterType((*MsgSubmitSignatures)(nil), "side.btcbridge.MsgSubmitSignatures") @@ -1279,81 +1456,87 @@ func init() { func init() { proto.RegisterFile("side/btcbridge/tx.proto", fileDescriptor_785ca8e1e4227068) } var fileDescriptor_785ca8e1e4227068 = []byte{ - // 1174 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0x4d, 0x6f, 0xdb, 0x46, - 0x13, 0xb6, 0x3e, 0xa2, 0xd8, 0x23, 0x4b, 0xb6, 0x19, 0xbf, 0x8e, 0x4c, 0x27, 0xb2, 0x23, 0xc7, - 0x1f, 0x80, 0xf3, 0x4a, 0x80, 0x92, 0x43, 0xd1, 0x53, 0x23, 0x1b, 0x48, 0x8a, 0x40, 0x41, 0xc0, - 0xd8, 0x69, 0xd1, 0x1e, 0x84, 0x25, 0xb9, 0xa6, 0xd8, 0x4a, 0x5c, 0x76, 0x77, 0xe9, 0xca, 0x40, - 0x81, 0x9e, 0x7a, 0x2c, 0xd0, 0x73, 0xfb, 0x07, 0xfa, 0x53, 0x72, 0xcc, 0xb1, 0xa7, 0xb6, 0xb0, - 0x7f, 0x48, 0x8b, 0x5d, 0x52, 0x2b, 0x4a, 0x24, 0x2d, 0x07, 0xbd, 0xed, 0xce, 0x3c, 0x9c, 0x79, - 0x66, 0x76, 0x66, 0x67, 0x09, 0xf7, 0x99, 0x6b, 0xe3, 0x96, 0xc9, 0x2d, 0x93, 0xba, 0xb6, 0x83, - 0x5b, 0x7c, 0xd4, 0xf4, 0x29, 0xe1, 0x44, 0xab, 0x0a, 0x45, 0x53, 0x29, 0xf4, 0x75, 0x87, 0x38, - 0x44, 0xaa, 0x5a, 0x62, 0x15, 0xa2, 0xf4, 0xad, 0x99, 0xcf, 0x7d, 0x44, 0xd1, 0x90, 0x45, 0xca, - 0xfa, 0x8c, 0x52, 0xad, 0x42, 0x7d, 0xe3, 0x3b, 0xf8, 0x5f, 0x97, 0x39, 0x6f, 0x03, 0x73, 0xe8, - 0xf2, 0xce, 0x80, 0x58, 0xdf, 0xbe, 0xc4, 0xc8, 0xc6, 0x94, 0x69, 0x1b, 0x50, 0x62, 0xd8, 0xb3, - 0x31, 0xad, 0xe5, 0x76, 0x72, 0x87, 0x4b, 0x46, 0xb4, 0xd3, 0x3e, 0x83, 0x8a, 0x29, 0x70, 0xbd, - 0x7e, 0x08, 0xac, 0xe5, 0x77, 0x0a, 0x87, 0xe5, 0xf6, 0x56, 0x73, 0x9a, 0x6b, 0x33, 0x66, 0xcc, - 0x58, 0x36, 0x63, 0x96, 0x1b, 0xdb, 0xf0, 0x30, 0xd5, 0xa5, 0x81, 0x99, 0x4f, 0x3c, 0x86, 0x1b, - 0x5d, 0xb8, 0xdf, 0x65, 0xce, 0x99, 0x6f, 0x23, 0x8e, 0x5f, 0x13, 0xaf, 0xc3, 0x2d, 0x03, 0x0f, - 0xd0, 0xe5, 0x4d, 0xac, 0x74, 0x58, 0xa4, 0x11, 0x46, 0x12, 0x5a, 0x32, 0xd4, 0xbe, 0xf1, 0x08, - 0xb6, 0x33, 0xcc, 0x29, 0x8f, 0xbf, 0xe7, 0x60, 0x4b, 0x71, 0x3a, 0xc1, 0x3e, 0x61, 0x2e, 0x3f, - 0xa5, 0xc8, 0x63, 0xc8, 0xe2, 0x2e, 0xf1, 0x32, 0xdd, 0x3e, 0x80, 0x25, 0x19, 0x5a, 0x1f, 0xb1, - 0x7e, 0x2d, 0x2f, 0x55, 0x13, 0x81, 0xd6, 0x80, 0x8a, 0x4f, 0xf1, 0x45, 0x8f, 0x8f, 0x7a, 0xe6, - 0x25, 0xc7, 0xac, 0x56, 0x90, 0x88, 0xb2, 0x10, 0x9e, 0x8e, 0x3a, 0x42, 0xa4, 0x6d, 0xc2, 0xa2, - 0x52, 0x17, 0xa5, 0xfa, 0x2e, 0x8f, 0x54, 0xeb, 0x70, 0xc7, 0xa7, 0x84, 0x9c, 0xd7, 0xee, 0xc8, - 0x80, 0xc2, 0x4d, 0x63, 0x0f, 0x76, 0x6f, 0x60, 0xaa, 0x22, 0xfa, 0x29, 0x07, 0x0f, 0x14, 0xee, - 0x0b, 0x97, 0xf7, 0x6d, 0x8a, 0xbe, 0xff, 0xef, 0x21, 0xc5, 0xe9, 0x16, 0x32, 0xe8, 0x16, 0xe3, - 0x74, 0xf7, 0xe1, 0xf1, 0x4d, 0x34, 0x14, 0x5f, 0x04, 0xeb, 0x5d, 0xe6, 0x28, 0x04, 0xe9, 0xb8, - 0xdc, 0x22, 0x6e, 0x36, 0xcd, 0x0d, 0x28, 0xa1, 0x21, 0x09, 0x3c, 0x1e, 0x71, 0x8c, 0x76, 0x82, - 0xe0, 0x39, 0xc6, 0x3d, 0x8a, 0x38, 0x1e, 0x13, 0x3c, 0xc7, 0xd8, 0x40, 0x1c, 0x37, 0xea, 0x32, - 0x23, 0x09, 0x17, 0x8a, 0xc2, 0x19, 0xdc, 0x53, 0x54, 0xdf, 0xba, 0x8e, 0x87, 0x78, 0x40, 0x71, - 0x76, 0xc9, 0x69, 0x50, 0xe4, 0x23, 0xd7, 0x8e, 0xfc, 0xcb, 0xb5, 0x90, 0xf9, 0xcc, 0xe4, 0x91, - 0x67, 0xb9, 0x6e, 0x3c, 0x8c, 0x95, 0xd6, 0xc4, 0xac, 0xf2, 0xfa, 0x6b, 0x5e, 0x46, 0x7e, 0x4c, - 0x3c, 0x46, 0x06, 0xae, 0xa8, 0xd1, 0x77, 0x28, 0x18, 0x70, 0x26, 0x0e, 0x02, 0x05, 0xbc, 0x4f, - 0xa8, 0xcb, 0x2f, 0x23, 0xd7, 0x13, 0x81, 0xb6, 0x0b, 0x95, 0x0b, 0x81, 0xeb, 0x5d, 0x60, 0xca, - 0x5c, 0xe2, 0x49, 0x1a, 0x45, 0x63, 0x59, 0x0a, 0xdf, 0x85, 0xb2, 0x44, 0x32, 0x0a, 0x2a, 0x19, - 0x5a, 0x17, 0xd6, 0x4c, 0x6e, 0xf5, 0x2c, 0xe5, 0x56, 0xd8, 0x10, 0x05, 0x58, 0x6e, 0xef, 0x24, - 0x5a, 0x99, 0x5b, 0xc7, 0x71, 0x9c, 0xb1, 0x6a, 0xce, 0x48, 0xb4, 0x33, 0x58, 0xa7, 0x81, 0x87, - 0xd9, 0xb4, 0x41, 0x26, 0x4b, 0xb7, 0xdc, 0x6e, 0xcc, 0x5a, 0x34, 0x04, 0x76, 0xda, 0xe6, 0x3d, - 0x9a, 0x90, 0xb1, 0xe8, 0xc8, 0x12, 0xb9, 0x51, 0xc9, 0xfb, 0x2b, 0x0f, 0xd5, 0x2e, 0x73, 0x3e, - 0xf7, 0x5c, 0xee, 0x22, 0x8e, 0x4f, 0x5e, 0xbd, 0x98, 0x93, 0xb6, 0x0e, 0x2c, 0xfb, 0x88, 0x72, - 0xd7, 0x72, 0x7d, 0xe4, 0xf1, 0xf1, 0xe5, 0x55, 0x9f, 0xe5, 0x77, 0xf2, 0xea, 0xc5, 0x9b, 0x09, - 0xcc, 0x98, 0xfa, 0x46, 0x78, 0xe0, 0x7d, 0x8a, 0x59, 0x9f, 0x0c, 0x6c, 0x99, 0xd6, 0x8a, 0x31, - 0x11, 0x68, 0x9f, 0x42, 0x39, 0x3c, 0x18, 0x7e, 0xe9, 0xcb, 0x9e, 0x2e, 0x1c, 0x56, 0xdb, 0x9b, - 0xb3, 0x0e, 0x9e, 0x33, 0x86, 0xf9, 0xe9, 0xa5, 0x8f, 0x0d, 0x90, 0x68, 0xb1, 0x64, 0xda, 0x1e, - 0x54, 0x6d, 0x97, 0x21, 0x73, 0x80, 0x7b, 0x21, 0xae, 0x76, 0x67, 0x27, 0x77, 0xb8, 0x68, 0x54, - 0x22, 0x69, 0x47, 0x0a, 0xb5, 0x03, 0x58, 0xc1, 0x9e, 0x44, 0x71, 0xd1, 0x49, 0xe7, 0x98, 0xd6, - 0x4a, 0x12, 0x57, 0x0d, 0xc5, 0xa7, 0x91, 0x54, 0xdb, 0x87, 0x15, 0x8e, 0xa8, 0x83, 0x79, 0x2f, - 0xe0, 0x23, 0xd2, 0xf3, 0x82, 0x61, 0xed, 0xae, 0xe4, 0x5b, 0x09, 0xc5, 0x67, 0x7c, 0x44, 0x5e, - 0x07, 0xc3, 0xa9, 0x3a, 0x59, 0x9c, 0x6e, 0x9a, 0x1a, 0x6c, 0x4c, 0x27, 0x58, 0xe5, 0xfe, 0xb7, - 0x9c, 0xcc, 0xfd, 0x31, 0x19, 0xfa, 0x03, 0x1c, 0xe6, 0x3e, 0xab, 0x55, 0xaa, 0x90, 0x8f, 0x1a, - 0xa5, 0x68, 0xe4, 0x5d, 0x5b, 0xe0, 0x64, 0xd4, 0xe2, 0x0e, 0x11, 0x77, 0x45, 0xb4, 0xd3, 0x8e, - 0x60, 0x4d, 0xd4, 0x0f, 0xf6, 0x58, 0xc0, 0x7a, 0xc8, 0xb6, 0x29, 0x66, 0xe3, 0x5b, 0x71, 0x55, - 0x29, 0x9e, 0x87, 0x72, 0x71, 0x0c, 0x6c, 0xdc, 0x4e, 0x32, 0x4f, 0x4b, 0xc6, 0x44, 0x10, 0xf1, - 0x8e, 0x91, 0x53, 0xbc, 0x7f, 0xce, 0xc3, 0x6a, 0x97, 0x39, 0xe3, 0x24, 0xc9, 0x8a, 0x9a, 0x53, - 0x35, 0x7b, 0x50, 0x65, 0x24, 0xa0, 0x16, 0x9e, 0xe9, 0xb6, 0x4a, 0x28, 0x1d, 0xb7, 0xdb, 0x23, - 0x58, 0xb6, 0x31, 0x9b, 0xb4, 0x64, 0x41, 0x82, 0xca, 0x42, 0x36, 0x86, 0x7c, 0x02, 0x80, 0xc4, - 0xd1, 0xcb, 0xea, 0x90, 0xa1, 0xdd, 0x58, 0x1c, 0x4b, 0x68, 0xbc, 0x94, 0xd7, 0x2b, 0x33, 0x39, - 0x53, 0xd3, 0x40, 0x6c, 0xd2, 0x4e, 0xb8, 0x34, 0xef, 0x84, 0xef, 0x4e, 0x9f, 0xb0, 0x0e, 0xb5, - 0xd9, 0x74, 0xa8, 0x5c, 0x61, 0x58, 0x51, 0xa3, 0xf3, 0x8d, 0x7c, 0x56, 0xcc, 0xc9, 0xd4, 0x33, - 0x28, 0x85, 0xcf, 0x0f, 0x99, 0xa1, 0x72, 0x7b, 0x63, 0x36, 0xb6, 0xd0, 0x4a, 0xa7, 0xf8, 0xfe, - 0xcf, 0xed, 0x05, 0x23, 0xc2, 0x36, 0x36, 0x63, 0x03, 0x3f, 0x04, 0x8c, 0x19, 0xb4, 0xff, 0x59, - 0x84, 0x42, 0x97, 0x39, 0xda, 0x37, 0xa0, 0xa5, 0x3c, 0x52, 0xf6, 0x66, 0xcd, 0xa7, 0x3e, 0x2c, - 0xf4, 0xff, 0xdf, 0x0a, 0x36, 0xf6, 0xa9, 0xf9, 0xb0, 0x9e, 0xfa, 0xf8, 0x38, 0x48, 0x31, 0x93, - 0x06, 0xd4, 0x5b, 0xb7, 0x04, 0x2a, 0x8f, 0x3f, 0x40, 0x2d, 0xf3, 0xed, 0x71, 0x94, 0x49, 0x3e, - 0x09, 0xd6, 0x9f, 0x7e, 0x04, 0x58, 0x79, 0xff, 0x11, 0x36, 0xb3, 0xdf, 0x09, 0x4f, 0x32, 0x2d, - 0xa6, 0xa0, 0xf5, 0x67, 0x1f, 0x83, 0x56, 0x04, 0x1c, 0x58, 0x4b, 0x4e, 0xfe, 0xc7, 0x29, 0xa6, - 0x12, 0x28, 0xfd, 0xc9, 0x6d, 0x50, 0xca, 0x91, 0x0d, 0xab, 0x89, 0xf9, 0xbe, 0x9b, 0x49, 0x79, - 0x02, 0xd2, 0x8f, 0x6e, 0x01, 0x8a, 0x87, 0x93, 0x1c, 0xe7, 0x69, 0xe1, 0x24, 0x50, 0xa9, 0xe1, - 0x64, 0x8e, 0x3f, 0xed, 0x0c, 0xca, 0xf1, 0xd1, 0x57, 0x4f, 0xf9, 0x38, 0xa6, 0xd7, 0xf7, 0x6f, - 0xd6, 0xc7, 0xcd, 0xc6, 0x6f, 0xf5, 0x7a, 0x2a, 0x27, 0xa5, 0x4f, 0x35, 0x9b, 0x72, 0xf1, 0x6a, - 0x5f, 0x43, 0x65, 0xfa, 0xd2, 0xdd, 0x49, 0xf9, 0x70, 0x0a, 0xa1, 0x1f, 0xce, 0x43, 0x28, 0xe3, - 0x5f, 0xc2, 0xf2, 0xd4, 0x35, 0xb5, 0x9d, 0xd9, 0x82, 0x21, 0x40, 0x3f, 0x98, 0x03, 0x18, 0x5b, - 0xee, 0xbc, 0x7c, 0x7f, 0x55, 0xcf, 0x7d, 0xb8, 0xaa, 0xe7, 0xfe, 0xbe, 0xaa, 0xe7, 0x7e, 0xb9, - 0xae, 0x2f, 0x7c, 0xb8, 0xae, 0x2f, 0xfc, 0x71, 0x5d, 0x5f, 0xf8, 0xaa, 0xe9, 0xb8, 0xbc, 0x1f, - 0x98, 0x4d, 0x8b, 0x0c, 0x5b, 0xc2, 0x98, 0xfc, 0xa3, 0xb2, 0xc8, 0x40, 0x6e, 0x5a, 0xa3, 0xf8, - 0x1f, 0x9d, 0x18, 0xef, 0x66, 0x49, 0x02, 0x9e, 0xfe, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x77, 0x2f, - 0x7b, 0x68, 0xf0, 0x0d, 0x00, 0x00, + // 1265 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0xcf, 0x6e, 0xdb, 0x46, + 0x13, 0xb7, 0x24, 0xc7, 0x7f, 0x46, 0x96, 0xe2, 0x30, 0xfe, 0x1c, 0x99, 0x4e, 0x68, 0x87, 0x89, + 0x1d, 0x01, 0xc9, 0x27, 0x03, 0x4e, 0x50, 0x14, 0x3d, 0x35, 0x4a, 0x9a, 0xa4, 0x08, 0x9c, 0x06, + 0x8c, 0x9d, 0x16, 0xed, 0x41, 0x58, 0x92, 0x6b, 0x8a, 0xad, 0xc4, 0x65, 0x77, 0x97, 0xa9, 0x0c, + 0x14, 0xe8, 0x29, 0xc7, 0x02, 0x3d, 0xb7, 0x2f, 0xd0, 0x47, 0xc9, 0x31, 0xc7, 0x9e, 0xda, 0x22, + 0xe9, 0x83, 0x14, 0xbb, 0x24, 0x57, 0xa4, 0x44, 0x4a, 0x0e, 0x7a, 0xdb, 0x9d, 0xf9, 0xf1, 0x37, + 0xb3, 0xb3, 0x33, 0xb3, 0x43, 0xb8, 0xc2, 0x7c, 0x17, 0x1f, 0xd8, 0xdc, 0xb1, 0xa9, 0xef, 0x7a, + 0xf8, 0x80, 0x8f, 0x3a, 0x21, 0x25, 0x9c, 0x68, 0x4d, 0xa1, 0xe8, 0x28, 0x85, 0xbe, 0xe1, 0x11, + 0x8f, 0x48, 0xd5, 0x81, 0x58, 0xc5, 0x28, 0x7d, 0x7b, 0xe2, 0xf3, 0x10, 0x51, 0x34, 0x64, 0x89, + 0xd2, 0x98, 0x50, 0xaa, 0x55, 0xac, 0x37, 0xbf, 0x87, 0xff, 0x1d, 0x31, 0xef, 0x45, 0x64, 0x0f, + 0x7d, 0xde, 0x1d, 0x10, 0xe7, 0xbb, 0x27, 0x18, 0xb9, 0x98, 0x32, 0x6d, 0x13, 0x96, 0x18, 0x0e, + 0x5c, 0x4c, 0x5b, 0x95, 0xdd, 0x4a, 0x7b, 0xd5, 0x4a, 0x76, 0xda, 0xa7, 0xd0, 0xb0, 0x05, 0xae, + 0xd7, 0x8f, 0x81, 0xad, 0xea, 0x6e, 0xad, 0x5d, 0x3f, 0xdc, 0xee, 0xe4, 0x7d, 0xed, 0x64, 0xc8, + 0xac, 0x35, 0x3b, 0xc3, 0x6c, 0xee, 0xc0, 0xb5, 0x42, 0x93, 0x16, 0x66, 0x21, 0x09, 0x18, 0x36, + 0x7f, 0xaf, 0xc0, 0xb6, 0x42, 0x3c, 0xc4, 0x21, 0x61, 0x3e, 0x3f, 0xa6, 0x28, 0x60, 0xc8, 0xe1, + 0x3e, 0x09, 0x4a, 0x5d, 0xbb, 0x0a, 0xab, 0xd2, 0x50, 0x1f, 0xb1, 0x7e, 0xab, 0x2a, 0x55, 0x63, + 0x81, 0x66, 0x42, 0x23, 0xa4, 0xf8, 0x55, 0x8f, 0x8f, 0x7a, 0xf6, 0x19, 0xc7, 0xac, 0x55, 0x93, + 0x88, 0xba, 0x10, 0x1e, 0x8f, 0xba, 0x42, 0xa4, 0x6d, 0xc1, 0x8a, 0x52, 0x2f, 0x4a, 0xf5, 0x32, + 0x4f, 0x54, 0x1b, 0x70, 0x21, 0xa4, 0x84, 0x9c, 0xb6, 0x2e, 0xec, 0xd6, 0xda, 0xab, 0x56, 0xbc, + 0x31, 0xf7, 0xe0, 0xc6, 0x0c, 0x4f, 0xd5, 0x89, 0x5e, 0x57, 0xe0, 0xaa, 0xc2, 0x7d, 0xe9, 0xf3, + 0xbe, 0x4b, 0xd1, 0x0f, 0xff, 0xfd, 0x48, 0x59, 0x77, 0x6b, 0x25, 0xee, 0x2e, 0x66, 0xdd, 0xdd, + 0x87, 0x9b, 0xb3, 0xdc, 0x50, 0xfe, 0x7e, 0x06, 0xeb, 0x0a, 0xf7, 0x08, 0x63, 0x0b, 0x71, 0x5c, + 0xea, 0xe2, 0x16, 0xac, 0x9c, 0x62, 0xdc, 0xa3, 0x88, 0x63, 0xe9, 0x61, 0xcd, 0x5a, 0x3e, 0x8d, + 0x3f, 0x31, 0x75, 0x68, 0x4d, 0xd2, 0x28, 0x13, 0xc7, 0x60, 0x1c, 0x31, 0xef, 0x24, 0x74, 0x11, + 0xc7, 0xc7, 0x34, 0x62, 0x1c, 0xbb, 0xcf, 0x48, 0xd0, 0xe5, 0x8e, 0x85, 0x07, 0xe8, 0x6c, 0x56, + 0x06, 0xea, 0xb0, 0x42, 0x13, 0x8c, 0x4c, 0xbe, 0x55, 0x4b, 0xed, 0xcd, 0x36, 0xec, 0xcf, 0x66, + 0x55, 0xf6, 0x9f, 0xc2, 0x95, 0x49, 0xe4, 0x17, 0x14, 0x39, 0x03, 0x5c, 0x6e, 0xb8, 0x05, 0xcb, + 0x24, 0x86, 0x24, 0x76, 0xd3, 0xad, 0x79, 0x1d, 0x76, 0x4a, 0xc8, 0x94, 0xbd, 0x47, 0xb0, 0x71, + 0xc4, 0x3c, 0x15, 0x74, 0xd2, 0xf5, 0xb9, 0x43, 0xfc, 0xf2, 0x9b, 0xdf, 0x84, 0x25, 0x34, 0x24, + 0x51, 0xc0, 0x93, 0x6b, 0x4f, 0x76, 0xa6, 0x21, 0x33, 0x69, 0x8a, 0x47, 0xd9, 0x39, 0x81, 0xcb, + 0x2a, 0xe6, 0x2f, 0x7c, 0x2f, 0x40, 0x3c, 0xa2, 0x33, 0xce, 0xa4, 0xc1, 0x22, 0x1f, 0xf9, 0x6e, + 0x62, 0x44, 0xae, 0x85, 0x2c, 0x64, 0x36, 0x4f, 0x52, 0x4a, 0xae, 0xcd, 0x6b, 0x99, 0x92, 0x1c, + 0xd3, 0x2a, 0xab, 0xbf, 0x56, 0xe5, 0xf1, 0x1e, 0x90, 0x80, 0x91, 0x81, 0x2f, 0xc2, 0xf0, 0x12, + 0x45, 0x03, 0xce, 0x44, 0x02, 0xa3, 0x88, 0xf7, 0x09, 0xf5, 0xf9, 0x59, 0x62, 0x7a, 0x2c, 0xd0, + 0x6e, 0x40, 0xe3, 0x95, 0xc0, 0xf5, 0x5e, 0x61, 0xca, 0x7c, 0x12, 0x48, 0x37, 0x16, 0xad, 0x35, + 0x29, 0x7c, 0x19, 0xcb, 0x72, 0x09, 0x56, 0xcb, 0x25, 0x98, 0x76, 0x04, 0x97, 0x6c, 0xee, 0xf4, + 0x1c, 0x65, 0x56, 0x70, 0x88, 0xc2, 0xad, 0x1f, 0xee, 0x4e, 0x35, 0x24, 0xee, 0x3c, 0xc8, 0xe2, + 0xac, 0x75, 0x7b, 0x42, 0xa2, 0x9d, 0xc0, 0x06, 0x8d, 0x02, 0xcc, 0xf2, 0x84, 0x4c, 0x96, 0x7c, + 0xfd, 0xd0, 0x9c, 0x64, 0xb4, 0x04, 0x36, 0xcf, 0x79, 0x99, 0x4e, 0xc9, 0x58, 0x72, 0x65, 0x53, + 0xb1, 0x51, 0xc1, 0xfb, 0xab, 0x0a, 0xcd, 0x23, 0xe6, 0x7d, 0x1e, 0xf8, 0xdc, 0x47, 0x1c, 0x3f, + 0x7c, 0xfa, 0x78, 0x4e, 0xd8, 0xba, 0xb0, 0x16, 0x22, 0xca, 0x7d, 0xc7, 0x0f, 0x51, 0xc0, 0xd3, + 0x16, 0x6c, 0x4c, 0xfa, 0xf7, 0xf0, 0xe9, 0xe3, 0xe7, 0x63, 0x98, 0x95, 0xfb, 0x46, 0x58, 0xe0, + 0x7d, 0x8a, 0x59, 0x9f, 0x0c, 0x5c, 0x19, 0xd6, 0x86, 0x35, 0x16, 0x68, 0x9f, 0x40, 0x3d, 0xbe, + 0x18, 0x7e, 0x16, 0xca, 0x5e, 0x58, 0x6b, 0x37, 0x0f, 0xb7, 0x26, 0x0d, 0xdc, 0x67, 0x0c, 0xf3, + 0xe3, 0xb3, 0x10, 0x5b, 0x20, 0xd1, 0x62, 0xc9, 0xb4, 0x3d, 0x68, 0xba, 0x3e, 0x43, 0xf6, 0x00, + 0xf7, 0x62, 0x5c, 0xeb, 0xc2, 0x6e, 0xa5, 0xbd, 0x62, 0x35, 0x12, 0x69, 0x57, 0x0a, 0xb5, 0x5b, + 0x70, 0x11, 0x07, 0x12, 0xc5, 0x45, 0x07, 0x3a, 0xc5, 0xb4, 0xb5, 0x24, 0x71, 0xcd, 0x58, 0x7c, + 0x9c, 0x48, 0xb5, 0x7d, 0xb8, 0xc8, 0x11, 0xf5, 0x30, 0xef, 0x45, 0x7c, 0x44, 0x7a, 0x41, 0x34, + 0x6c, 0x2d, 0x4b, 0x7f, 0x1b, 0xb1, 0xf8, 0x84, 0x8f, 0xc8, 0xb3, 0x68, 0x98, 0xcb, 0x93, 0x95, + 0xb8, 0x1b, 0xa6, 0x8d, 0xa8, 0x05, 0x9b, 0xf9, 0x00, 0xab, 0xd8, 0xff, 0x56, 0x91, 0xb1, 0x7f, + 0x40, 0x86, 0xe1, 0x00, 0xc7, 0xb1, 0x2f, 0x2b, 0x95, 0x26, 0x54, 0x93, 0x42, 0x59, 0xb4, 0xaa, + 0xbe, 0x2b, 0x70, 0xf2, 0xd4, 0xa2, 0xf7, 0x8a, 0x6e, 0x90, 0xec, 0xb4, 0xdb, 0x70, 0x49, 0xe4, + 0x0f, 0x0e, 0x58, 0xc4, 0x7a, 0xc8, 0x75, 0x29, 0x66, 0xe9, 0x6b, 0xb2, 0xae, 0x14, 0xf7, 0x63, + 0xb9, 0xb8, 0x06, 0x96, 0x96, 0x93, 0x8c, 0xd3, 0xaa, 0x35, 0x16, 0x24, 0x7e, 0x67, 0x9c, 0x53, + 0x7e, 0xff, 0x5c, 0x95, 0x2d, 0x3a, 0x0d, 0x92, 0xcc, 0xa8, 0x39, 0x59, 0xb3, 0x07, 0x4d, 0x46, + 0x22, 0xea, 0xe0, 0x89, 0x6a, 0x6b, 0xc4, 0xd2, 0xb4, 0xdc, 0xae, 0xc3, 0x9a, 0x8b, 0xd9, 0xb8, + 0x24, 0x6b, 0x12, 0x54, 0x17, 0xb2, 0x14, 0xf2, 0x31, 0x00, 0x12, 0x57, 0x2f, 0xb3, 0x43, 0x1e, + 0x6d, 0x66, 0x72, 0xac, 0xa2, 0x74, 0x29, 0x9f, 0x25, 0x66, 0x73, 0xa6, 0x5e, 0x51, 0xb1, 0x29, + 0xba, 0xe1, 0xa5, 0x79, 0x37, 0xbc, 0x9c, 0xbf, 0xe1, 0xf8, 0xa9, 0xc9, 0x85, 0x43, 0xc5, 0x0a, + 0xc3, 0x45, 0xd5, 0x9d, 0x9f, 0xcb, 0xe1, 0x68, 0x4e, 0xa4, 0xee, 0xc1, 0x52, 0x3c, 0x44, 0xc9, + 0x08, 0xd5, 0x0f, 0x37, 0x27, 0xcf, 0x16, 0xb3, 0x74, 0x17, 0xdf, 0xfc, 0xb9, 0xb3, 0x60, 0x25, + 0x58, 0x73, 0x2b, 0xf3, 0xa2, 0xc4, 0x80, 0xd4, 0x83, 0xc3, 0x7f, 0x00, 0x6a, 0x47, 0xcc, 0xd3, + 0xbe, 0x05, 0xad, 0x60, 0xd4, 0xda, 0x9b, 0xa4, 0x2f, 0x1c, 0x8f, 0xf4, 0xff, 0x9f, 0x0b, 0x96, + 0xda, 0xd4, 0x7e, 0x84, 0x56, 0xe9, 0x04, 0x75, 0xbb, 0x94, 0x6a, 0x1a, 0xac, 0xdf, 0xfd, 0x00, + 0xb0, 0xb2, 0xfe, 0x13, 0x6c, 0x95, 0x4f, 0x3b, 0x77, 0x4a, 0x19, 0x0b, 0xd0, 0xfa, 0xbd, 0x0f, + 0x41, 0x2b, 0x07, 0xbe, 0x81, 0x46, 0x7e, 0x7e, 0xd9, 0x2d, 0xa5, 0x49, 0x10, 0x7a, 0x7b, 0x1e, + 0x42, 0x91, 0xbf, 0xae, 0xc0, 0xf6, 0xac, 0xd1, 0xa5, 0x53, 0xc0, 0x34, 0x03, 0xaf, 0x7f, 0xf4, + 0x61, 0x78, 0xe5, 0x47, 0x08, 0x1b, 0x85, 0x13, 0xcc, 0xad, 0x79, 0x7c, 0x09, 0x50, 0x3f, 0x38, + 0x27, 0x50, 0x59, 0xf4, 0xe0, 0xd2, 0xf4, 0x0c, 0x73, 0xb3, 0x80, 0x65, 0x0a, 0xa5, 0xdf, 0x39, + 0x0f, 0x4a, 0x19, 0x72, 0x61, 0x7d, 0x6a, 0x88, 0xb9, 0x51, 0x7a, 0x41, 0x63, 0x90, 0x7e, 0xfb, + 0x1c, 0xa0, 0xec, 0x71, 0xa6, 0x67, 0x96, 0xa2, 0xe3, 0x4c, 0xa1, 0x0a, 0x8f, 0x53, 0xfa, 0xc6, + 0x6b, 0x27, 0x50, 0xcf, 0xbe, 0xef, 0x46, 0xc1, 0xc7, 0x19, 0xbd, 0xbe, 0x3f, 0x5b, 0x9f, 0xa5, + 0xcd, 0x3e, 0x5d, 0x46, 0xa1, 0x4f, 0x4a, 0x5f, 0x48, 0x5b, 0xf0, 0xba, 0x88, 0xe2, 0xc9, 0xbf, + 0x2c, 0x45, 0xc5, 0x93, 0x43, 0x14, 0x16, 0x4f, 0x61, 0x3b, 0xd6, 0xbe, 0x82, 0xb5, 0x5c, 0x2f, + 0xde, 0x29, 0xcd, 0xc1, 0x18, 0xa0, 0xdf, 0x9a, 0x03, 0x48, 0x99, 0xbb, 0x4f, 0xde, 0xbc, 0x33, + 0x2a, 0x6f, 0xdf, 0x19, 0x95, 0xbf, 0xdf, 0x19, 0x95, 0x5f, 0xde, 0x1b, 0x0b, 0x6f, 0xdf, 0x1b, + 0x0b, 0x7f, 0xbc, 0x37, 0x16, 0xbe, 0xee, 0x78, 0x3e, 0xef, 0x47, 0x76, 0xc7, 0x21, 0xc3, 0x03, + 0x41, 0x26, 0x7f, 0x7e, 0x1d, 0x32, 0x90, 0x9b, 0x83, 0x51, 0xf6, 0xe7, 0x5b, 0xcc, 0x30, 0xf6, + 0x92, 0x04, 0xdc, 0xfd, 0x37, 0x00, 0x00, 0xff, 0xff, 0x42, 0x95, 0xfb, 0xbc, 0x9b, 0x0f, 0x00, + 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1370,12 +1553,16 @@ const _ = grpc.SupportPackageIsVersion4 type MsgClient interface { // SubmitBlockHeaders submits bitcoin block headers to the side chain. SubmitBlockHeaders(ctx context.Context, in *MsgSubmitBlockHeaders, opts ...grpc.CallOption) (*MsgSubmitBlockHeadersResponse, error) - // UpdateNonBtcRelayers updates the trusted non-btc asset relayers. - UpdateNonBtcRelayers(ctx context.Context, in *MsgUpdateNonBtcRelayers, opts ...grpc.CallOption) (*MsgUpdateNonBtcRelayersResponse, error) - // SubmitDepositTransaction submits bitcoin transaction to the side chain. + // SubmitDepositTransaction submits the bitcoin deposit transaction to the side chain. SubmitDepositTransaction(ctx context.Context, in *MsgSubmitDepositTransaction, opts ...grpc.CallOption) (*MsgSubmitDepositTransactionResponse, error) - // SubmitWithdrawalTransaction submits bitcoin transaction to the side chain. + // SubmitWithdrawalTransaction submits the bitcoin withdrawal transaction to the side chain. SubmitWithdrawTransaction(ctx context.Context, in *MsgSubmitWithdrawTransaction, opts ...grpc.CallOption) (*MsgSubmitWithdrawTransactionResponse, error) + // SubmitFeeRate submits the bitcoin network fee rate to the side chain. + SubmitFeeRate(ctx context.Context, in *MsgSubmitFeeRate, opts ...grpc.CallOption) (*MsgSubmitFeeRateResponse, error) + // UpdateTrustedNonBtcRelayers updates the trusted non-btc asset relayers. + UpdateTrustedNonBtcRelayers(ctx context.Context, in *MsgUpdateTrustedNonBtcRelayers, opts ...grpc.CallOption) (*MsgUpdateTrustedNonBtcRelayersResponse, error) + // UpdateTrustedOracles updates the trusted oracles. + UpdateTrustedOracles(ctx context.Context, in *MsgUpdateTrustedOracles, opts ...grpc.CallOption) (*MsgUpdateTrustedOraclesResponse, error) // WithdrawToBitcoin withdraws the asset to bitcoin. WithdrawToBitcoin(ctx context.Context, in *MsgWithdrawToBitcoin, opts ...grpc.CallOption) (*MsgWithdrawToBitcoinResponse, error) // SubmitSignatures submits the signatures of the signing request to the side chain. @@ -1412,15 +1599,6 @@ func (c *msgClient) SubmitBlockHeaders(ctx context.Context, in *MsgSubmitBlockHe return out, nil } -func (c *msgClient) UpdateNonBtcRelayers(ctx context.Context, in *MsgUpdateNonBtcRelayers, opts ...grpc.CallOption) (*MsgUpdateNonBtcRelayersResponse, error) { - out := new(MsgUpdateNonBtcRelayersResponse) - err := c.cc.Invoke(ctx, "/side.btcbridge.Msg/UpdateNonBtcRelayers", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - func (c *msgClient) SubmitDepositTransaction(ctx context.Context, in *MsgSubmitDepositTransaction, opts ...grpc.CallOption) (*MsgSubmitDepositTransactionResponse, error) { out := new(MsgSubmitDepositTransactionResponse) err := c.cc.Invoke(ctx, "/side.btcbridge.Msg/SubmitDepositTransaction", in, out, opts...) @@ -1439,6 +1617,33 @@ func (c *msgClient) SubmitWithdrawTransaction(ctx context.Context, in *MsgSubmit return out, nil } +func (c *msgClient) SubmitFeeRate(ctx context.Context, in *MsgSubmitFeeRate, opts ...grpc.CallOption) (*MsgSubmitFeeRateResponse, error) { + out := new(MsgSubmitFeeRateResponse) + err := c.cc.Invoke(ctx, "/side.btcbridge.Msg/SubmitFeeRate", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) UpdateTrustedNonBtcRelayers(ctx context.Context, in *MsgUpdateTrustedNonBtcRelayers, opts ...grpc.CallOption) (*MsgUpdateTrustedNonBtcRelayersResponse, error) { + out := new(MsgUpdateTrustedNonBtcRelayersResponse) + err := c.cc.Invoke(ctx, "/side.btcbridge.Msg/UpdateTrustedNonBtcRelayers", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) UpdateTrustedOracles(ctx context.Context, in *MsgUpdateTrustedOracles, opts ...grpc.CallOption) (*MsgUpdateTrustedOraclesResponse, error) { + out := new(MsgUpdateTrustedOraclesResponse) + err := c.cc.Invoke(ctx, "/side.btcbridge.Msg/UpdateTrustedOracles", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *msgClient) WithdrawToBitcoin(ctx context.Context, in *MsgWithdrawToBitcoin, opts ...grpc.CallOption) (*MsgWithdrawToBitcoinResponse, error) { out := new(MsgWithdrawToBitcoinResponse) err := c.cc.Invoke(ctx, "/side.btcbridge.Msg/WithdrawToBitcoin", in, out, opts...) @@ -1506,12 +1711,16 @@ func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts type MsgServer interface { // SubmitBlockHeaders submits bitcoin block headers to the side chain. SubmitBlockHeaders(context.Context, *MsgSubmitBlockHeaders) (*MsgSubmitBlockHeadersResponse, error) - // UpdateNonBtcRelayers updates the trusted non-btc asset relayers. - UpdateNonBtcRelayers(context.Context, *MsgUpdateNonBtcRelayers) (*MsgUpdateNonBtcRelayersResponse, error) - // SubmitDepositTransaction submits bitcoin transaction to the side chain. + // SubmitDepositTransaction submits the bitcoin deposit transaction to the side chain. SubmitDepositTransaction(context.Context, *MsgSubmitDepositTransaction) (*MsgSubmitDepositTransactionResponse, error) - // SubmitWithdrawalTransaction submits bitcoin transaction to the side chain. + // SubmitWithdrawalTransaction submits the bitcoin withdrawal transaction to the side chain. SubmitWithdrawTransaction(context.Context, *MsgSubmitWithdrawTransaction) (*MsgSubmitWithdrawTransactionResponse, error) + // SubmitFeeRate submits the bitcoin network fee rate to the side chain. + SubmitFeeRate(context.Context, *MsgSubmitFeeRate) (*MsgSubmitFeeRateResponse, error) + // UpdateTrustedNonBtcRelayers updates the trusted non-btc asset relayers. + UpdateTrustedNonBtcRelayers(context.Context, *MsgUpdateTrustedNonBtcRelayers) (*MsgUpdateTrustedNonBtcRelayersResponse, error) + // UpdateTrustedOracles updates the trusted oracles. + UpdateTrustedOracles(context.Context, *MsgUpdateTrustedOracles) (*MsgUpdateTrustedOraclesResponse, error) // WithdrawToBitcoin withdraws the asset to bitcoin. WithdrawToBitcoin(context.Context, *MsgWithdrawToBitcoin) (*MsgWithdrawToBitcoinResponse, error) // SubmitSignatures submits the signatures of the signing request to the side chain. @@ -1538,15 +1747,21 @@ type UnimplementedMsgServer struct { func (*UnimplementedMsgServer) SubmitBlockHeaders(ctx context.Context, req *MsgSubmitBlockHeaders) (*MsgSubmitBlockHeadersResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SubmitBlockHeaders not implemented") } -func (*UnimplementedMsgServer) UpdateNonBtcRelayers(ctx context.Context, req *MsgUpdateNonBtcRelayers) (*MsgUpdateNonBtcRelayersResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method UpdateNonBtcRelayers not implemented") -} func (*UnimplementedMsgServer) SubmitDepositTransaction(ctx context.Context, req *MsgSubmitDepositTransaction) (*MsgSubmitDepositTransactionResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SubmitDepositTransaction not implemented") } func (*UnimplementedMsgServer) SubmitWithdrawTransaction(ctx context.Context, req *MsgSubmitWithdrawTransaction) (*MsgSubmitWithdrawTransactionResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SubmitWithdrawTransaction not implemented") } +func (*UnimplementedMsgServer) SubmitFeeRate(ctx context.Context, req *MsgSubmitFeeRate) (*MsgSubmitFeeRateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SubmitFeeRate not implemented") +} +func (*UnimplementedMsgServer) UpdateTrustedNonBtcRelayers(ctx context.Context, req *MsgUpdateTrustedNonBtcRelayers) (*MsgUpdateTrustedNonBtcRelayersResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateTrustedNonBtcRelayers not implemented") +} +func (*UnimplementedMsgServer) UpdateTrustedOracles(ctx context.Context, req *MsgUpdateTrustedOracles) (*MsgUpdateTrustedOraclesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateTrustedOracles not implemented") +} func (*UnimplementedMsgServer) WithdrawToBitcoin(ctx context.Context, req *MsgWithdrawToBitcoin) (*MsgWithdrawToBitcoinResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method WithdrawToBitcoin not implemented") } @@ -1591,56 +1806,92 @@ func _Msg_SubmitBlockHeaders_Handler(srv interface{}, ctx context.Context, dec f return interceptor(ctx, in, info, handler) } -func _Msg_UpdateNonBtcRelayers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgUpdateNonBtcRelayers) +func _Msg_SubmitDepositTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgSubmitDepositTransaction) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(MsgServer).UpdateNonBtcRelayers(ctx, in) + return srv.(MsgServer).SubmitDepositTransaction(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/side.btcbridge.Msg/UpdateNonBtcRelayers", + FullMethod: "/side.btcbridge.Msg/SubmitDepositTransaction", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).UpdateNonBtcRelayers(ctx, req.(*MsgUpdateNonBtcRelayers)) + return srv.(MsgServer).SubmitDepositTransaction(ctx, req.(*MsgSubmitDepositTransaction)) } return interceptor(ctx, in, info, handler) } -func _Msg_SubmitDepositTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgSubmitDepositTransaction) +func _Msg_SubmitWithdrawTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgSubmitWithdrawTransaction) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(MsgServer).SubmitDepositTransaction(ctx, in) + return srv.(MsgServer).SubmitWithdrawTransaction(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/side.btcbridge.Msg/SubmitDepositTransaction", + FullMethod: "/side.btcbridge.Msg/SubmitWithdrawTransaction", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).SubmitDepositTransaction(ctx, req.(*MsgSubmitDepositTransaction)) + return srv.(MsgServer).SubmitWithdrawTransaction(ctx, req.(*MsgSubmitWithdrawTransaction)) } return interceptor(ctx, in, info, handler) } -func _Msg_SubmitWithdrawTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgSubmitWithdrawTransaction) +func _Msg_SubmitFeeRate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgSubmitFeeRate) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(MsgServer).SubmitWithdrawTransaction(ctx, in) + return srv.(MsgServer).SubmitFeeRate(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/side.btcbridge.Msg/SubmitWithdrawTransaction", + FullMethod: "/side.btcbridge.Msg/SubmitFeeRate", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).SubmitWithdrawTransaction(ctx, req.(*MsgSubmitWithdrawTransaction)) + return srv.(MsgServer).SubmitFeeRate(ctx, req.(*MsgSubmitFeeRate)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_UpdateTrustedNonBtcRelayers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateTrustedNonBtcRelayers) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateTrustedNonBtcRelayers(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/side.btcbridge.Msg/UpdateTrustedNonBtcRelayers", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateTrustedNonBtcRelayers(ctx, req.(*MsgUpdateTrustedNonBtcRelayers)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_UpdateTrustedOracles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateTrustedOracles) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateTrustedOracles(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/side.btcbridge.Msg/UpdateTrustedOracles", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateTrustedOracles(ctx, req.(*MsgUpdateTrustedOracles)) } return interceptor(ctx, in, info, handler) } @@ -1779,10 +2030,6 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ MethodName: "SubmitBlockHeaders", Handler: _Msg_SubmitBlockHeaders_Handler, }, - { - MethodName: "UpdateNonBtcRelayers", - Handler: _Msg_UpdateNonBtcRelayers_Handler, - }, { MethodName: "SubmitDepositTransaction", Handler: _Msg_SubmitDepositTransaction_Handler, @@ -1791,6 +2038,18 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ MethodName: "SubmitWithdrawTransaction", Handler: _Msg_SubmitWithdrawTransaction_Handler, }, + { + MethodName: "SubmitFeeRate", + Handler: _Msg_SubmitFeeRate_Handler, + }, + { + MethodName: "UpdateTrustedNonBtcRelayers", + Handler: _Msg_UpdateTrustedNonBtcRelayers_Handler, + }, + { + MethodName: "UpdateTrustedOracles", + Handler: _Msg_UpdateTrustedOracles_Handler, + }, { MethodName: "WithdrawToBitcoin", Handler: _Msg_WithdrawToBitcoin_Handler, @@ -1891,68 +2150,6 @@ func (m *MsgSubmitBlockHeadersResponse) MarshalToSizedBuffer(dAtA []byte) (int, return len(dAtA) - i, nil } -func (m *MsgUpdateNonBtcRelayers) 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 *MsgUpdateNonBtcRelayers) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgUpdateNonBtcRelayers) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Relayers) > 0 { - for iNdEx := len(m.Relayers) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.Relayers[iNdEx]) - copy(dAtA[i:], m.Relayers[iNdEx]) - i = encodeVarintTx(dAtA, i, uint64(len(m.Relayers[iNdEx]))) - i-- - dAtA[i] = 0x12 - } - } - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *MsgUpdateNonBtcRelayersResponse) 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 *MsgUpdateNonBtcRelayersResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgUpdateNonBtcRelayersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil -} - func (m *MsgSubmitDepositTransaction) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -2112,7 +2309,7 @@ func (m *MsgSubmitWithdrawTransactionResponse) MarshalToSizedBuffer(dAtA []byte) return len(dAtA) - i, nil } -func (m *MsgWithdrawToBitcoin) Marshal() (dAtA []byte, err error) { +func (m *MsgSubmitFeeRate) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2122,29 +2319,20 @@ func (m *MsgWithdrawToBitcoin) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgWithdrawToBitcoin) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgSubmitFeeRate) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgWithdrawToBitcoin) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgSubmitFeeRate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.FeeRate) > 0 { - i -= len(m.FeeRate) - copy(dAtA[i:], m.FeeRate) - i = encodeVarintTx(dAtA, i, uint64(len(m.FeeRate))) - i-- - dAtA[i] = 0x1a - } - if len(m.Amount) > 0 { - i -= len(m.Amount) - copy(dAtA[i:], m.Amount) - i = encodeVarintTx(dAtA, i, uint64(len(m.Amount))) + if m.FeeRate != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.FeeRate)) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x10 } if len(m.Sender) > 0 { i -= len(m.Sender) @@ -2156,7 +2344,7 @@ func (m *MsgWithdrawToBitcoin) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *MsgWithdrawToBitcoinResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgSubmitFeeRateResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2166,12 +2354,12 @@ func (m *MsgWithdrawToBitcoinResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgWithdrawToBitcoinResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgSubmitFeeRateResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgWithdrawToBitcoinResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgSubmitFeeRateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -2179,7 +2367,7 @@ func (m *MsgWithdrawToBitcoinResponse) MarshalToSizedBuffer(dAtA []byte) (int, e return len(dAtA) - i, nil } -func (m *MsgSubmitSignatures) Marshal() (dAtA []byte, err error) { +func (m *MsgUpdateTrustedNonBtcRelayers) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2189,29 +2377,24 @@ func (m *MsgSubmitSignatures) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgSubmitSignatures) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgUpdateTrustedNonBtcRelayers) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgSubmitSignatures) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgUpdateTrustedNonBtcRelayers) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.Psbt) > 0 { - i -= len(m.Psbt) - copy(dAtA[i:], m.Psbt) - i = encodeVarintTx(dAtA, i, uint64(len(m.Psbt))) - i-- - dAtA[i] = 0x1a - } - if len(m.Txid) > 0 { - i -= len(m.Txid) - copy(dAtA[i:], m.Txid) - i = encodeVarintTx(dAtA, i, uint64(len(m.Txid))) - i-- - dAtA[i] = 0x12 + if len(m.Relayers) > 0 { + for iNdEx := len(m.Relayers) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Relayers[iNdEx]) + copy(dAtA[i:], m.Relayers[iNdEx]) + i = encodeVarintTx(dAtA, i, uint64(len(m.Relayers[iNdEx]))) + i-- + dAtA[i] = 0x12 + } } if len(m.Sender) > 0 { i -= len(m.Sender) @@ -2223,7 +2406,7 @@ func (m *MsgSubmitSignatures) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *MsgSubmitSignaturesResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgUpdateTrustedNonBtcRelayersResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2233,12 +2416,12 @@ func (m *MsgSubmitSignaturesResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgSubmitSignaturesResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgUpdateTrustedNonBtcRelayersResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgSubmitSignaturesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgUpdateTrustedNonBtcRelayersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -2246,7 +2429,7 @@ func (m *MsgSubmitSignaturesResponse) MarshalToSizedBuffer(dAtA []byte) (int, er return len(dAtA) - i, nil } -func (m *MsgConsolidateVaults) Marshal() (dAtA []byte, err error) { +func (m *MsgUpdateTrustedOracles) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2256,63 +2439,36 @@ func (m *MsgConsolidateVaults) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgConsolidateVaults) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgUpdateTrustedOracles) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgConsolidateVaults) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgUpdateTrustedOracles) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.RunesConsolidations) > 0 { - for iNdEx := len(m.RunesConsolidations) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.RunesConsolidations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } + if len(m.Oracles) > 0 { + for iNdEx := len(m.Oracles) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Oracles[iNdEx]) + copy(dAtA[i:], m.Oracles[iNdEx]) + i = encodeVarintTx(dAtA, i, uint64(len(m.Oracles[iNdEx]))) i-- - dAtA[i] = 0x2a - } - } - if m.BtcConsolidation != nil { - { - size, err := m.BtcConsolidation.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) + dAtA[i] = 0x12 } - i-- - dAtA[i] = 0x22 - } - if m.FeeRate != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.FeeRate)) - i-- - dAtA[i] = 0x18 - } - if m.VaultVersion != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.VaultVersion)) - i-- - dAtA[i] = 0x10 } - if len(m.Authority) > 0 { - i -= len(m.Authority) - copy(dAtA[i:], m.Authority) - i = encodeVarintTx(dAtA, i, uint64(len(m.Authority))) + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *MsgConsolidateVaultsResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgUpdateTrustedOraclesResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2322,12 +2478,12 @@ func (m *MsgConsolidateVaultsResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgConsolidateVaultsResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgUpdateTrustedOraclesResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgConsolidateVaultsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgUpdateTrustedOraclesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -2335,7 +2491,7 @@ func (m *MsgConsolidateVaultsResponse) MarshalToSizedBuffer(dAtA []byte) (int, e return len(dAtA) - i, nil } -func (m *MsgInitiateDKG) Marshal() (dAtA []byte, err error) { +func (m *MsgWithdrawToBitcoin) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2345,22 +2501,238 @@ func (m *MsgInitiateDKG) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgInitiateDKG) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgWithdrawToBitcoin) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgInitiateDKG) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgWithdrawToBitcoin) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.FeeRate) > 0 { - i -= len(m.FeeRate) - copy(dAtA[i:], m.FeeRate) - i = encodeVarintTx(dAtA, i, uint64(len(m.FeeRate))) - i-- - dAtA[i] = 0x42 + if len(m.Amount) > 0 { + i -= len(m.Amount) + copy(dAtA[i:], m.Amount) + i = encodeVarintTx(dAtA, i, uint64(len(m.Amount))) + i-- + dAtA[i] = 0x12 + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgWithdrawToBitcoinResponse) 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 *MsgWithdrawToBitcoinResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgWithdrawToBitcoinResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgSubmitSignatures) 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 *MsgSubmitSignatures) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgSubmitSignatures) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Psbt) > 0 { + i -= len(m.Psbt) + copy(dAtA[i:], m.Psbt) + i = encodeVarintTx(dAtA, i, uint64(len(m.Psbt))) + i-- + dAtA[i] = 0x1a + } + if len(m.Txid) > 0 { + i -= len(m.Txid) + copy(dAtA[i:], m.Txid) + i = encodeVarintTx(dAtA, i, uint64(len(m.Txid))) + i-- + dAtA[i] = 0x12 + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgSubmitSignaturesResponse) 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 *MsgSubmitSignaturesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgSubmitSignaturesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgConsolidateVaults) 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 *MsgConsolidateVaults) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgConsolidateVaults) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.RunesConsolidations) > 0 { + for iNdEx := len(m.RunesConsolidations) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RunesConsolidations[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + if m.BtcConsolidation != nil { + { + size, err := m.BtcConsolidation.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.FeeRate != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.FeeRate)) + i-- + dAtA[i] = 0x18 + } + if m.VaultVersion != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.VaultVersion)) + i-- + dAtA[i] = 0x10 + } + if len(m.Authority) > 0 { + i -= len(m.Authority) + copy(dAtA[i:], m.Authority) + i = encodeVarintTx(dAtA, i, uint64(len(m.Authority))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgConsolidateVaultsResponse) 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 *MsgConsolidateVaultsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgConsolidateVaultsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgInitiateDKG) 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 *MsgInitiateDKG) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgInitiateDKG) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.FeeRate) > 0 { + i -= len(m.FeeRate) + copy(dAtA[i:], m.FeeRate) + i = encodeVarintTx(dAtA, i, uint64(len(m.FeeRate))) + i-- + dAtA[i] = 0x42 } if m.TargetUtxoNum != 0 { i = encodeVarintTx(dAtA, i, uint64(m.TargetUtxoNum)) @@ -2729,34 +3101,6 @@ func (m *MsgSubmitBlockHeadersResponse) Size() (n int) { return n } -func (m *MsgUpdateNonBtcRelayers) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - if len(m.Relayers) > 0 { - for _, s := range m.Relayers { - l = len(s) - n += 1 + l + sovTx(uint64(l)) - } - } - return n -} - -func (m *MsgUpdateNonBtcRelayersResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n -} - func (m *MsgSubmitDepositTransaction) Size() (n int) { if m == nil { return 0 @@ -2833,7 +3177,7 @@ func (m *MsgSubmitWithdrawTransactionResponse) Size() (n int) { return n } -func (m *MsgWithdrawToBitcoin) Size() (n int) { +func (m *MsgSubmitFeeRate) Size() (n int) { if m == nil { return 0 } @@ -2843,12 +3187,89 @@ func (m *MsgWithdrawToBitcoin) Size() (n int) { if l > 0 { n += 1 + l + sovTx(uint64(l)) } - l = len(m.Amount) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if m.FeeRate != 0 { + n += 1 + sovTx(uint64(m.FeeRate)) } - l = len(m.FeeRate) - if l > 0 { + return n +} + +func (m *MsgSubmitFeeRateResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgUpdateTrustedNonBtcRelayers) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Relayers) > 0 { + for _, s := range m.Relayers { + l = len(s) + n += 1 + l + sovTx(uint64(l)) + } + } + return n +} + +func (m *MsgUpdateTrustedNonBtcRelayersResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgUpdateTrustedOracles) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Oracles) > 0 { + for _, s := range m.Oracles { + l = len(s) + n += 1 + l + sovTx(uint64(l)) + } + } + return n +} + +func (m *MsgUpdateTrustedOraclesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgWithdrawToBitcoin) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Amount) + if l > 0 { n += 1 + l + sovTx(uint64(l)) } return n @@ -3156,11 +3577,501 @@ func (m *MsgSubmitBlockHeaders) Unmarshal(dAtA []byte) error { } m.Sender = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 2: + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHeaders", 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 + } + m.BlockHeaders = append(m.BlockHeaders, &BlockHeader{}) + if err := m.BlockHeaders[len(m.BlockHeaders)-1].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 (m *MsgSubmitBlockHeadersResponse) 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: MsgSubmitBlockHeadersResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgSubmitBlockHeadersResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + 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 (m *MsgSubmitDepositTransaction) 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: MsgSubmitDepositTransaction: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgSubmitDepositTransaction: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Blockhash", 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.Blockhash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevTxBytes", 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.PrevTxBytes = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TxBytes", 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.TxBytes = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proof", 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.Proof = append(m.Proof, string(dAtA[iNdEx:postIndex])) + 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 (m *MsgSubmitDepositTransactionResponse) 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: MsgSubmitDepositTransactionResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgSubmitDepositTransactionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + 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 (m *MsgSubmitWithdrawTransaction) 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: MsgSubmitWithdrawTransaction: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgSubmitWithdrawTransaction: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Blockhash", 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.Blockhash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TxBytes", 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.TxBytes = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BlockHeaders", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -3170,25 +4081,23 @@ func (m *MsgSubmitBlockHeaders) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - m.BlockHeaders = append(m.BlockHeaders, &BlockHeader{}) - if err := m.BlockHeaders[len(m.BlockHeaders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Proof = append(m.Proof, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex @@ -3211,7 +4120,7 @@ func (m *MsgSubmitBlockHeaders) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgSubmitBlockHeadersResponse) Unmarshal(dAtA []byte) error { +func (m *MsgSubmitWithdrawTransactionResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3234,10 +4143,10 @@ func (m *MsgSubmitBlockHeadersResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgSubmitBlockHeadersResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgSubmitWithdrawTransactionResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgSubmitBlockHeadersResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgSubmitWithdrawTransactionResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -3261,7 +4170,7 @@ func (m *MsgSubmitBlockHeadersResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgUpdateNonBtcRelayers) Unmarshal(dAtA []byte) error { +func (m *MsgSubmitFeeRate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3284,10 +4193,10 @@ func (m *MsgUpdateNonBtcRelayers) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgUpdateNonBtcRelayers: wiretype end group for non-group") + return fmt.Errorf("proto: MsgSubmitFeeRate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgUpdateNonBtcRelayers: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgSubmitFeeRate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -3323,10 +4232,10 @@ func (m *MsgUpdateNonBtcRelayers) Unmarshal(dAtA []byte) error { m.Sender = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Relayers", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeRate", wireType) } - var stringLen uint64 + m.FeeRate = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -3336,24 +4245,11 @@ func (m *MsgUpdateNonBtcRelayers) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.FeeRate |= int64(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.Relayers = append(m.Relayers, string(dAtA[iNdEx:postIndex])) - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -3375,7 +4271,7 @@ func (m *MsgUpdateNonBtcRelayers) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgUpdateNonBtcRelayersResponse) Unmarshal(dAtA []byte) error { +func (m *MsgSubmitFeeRateResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3398,10 +4294,10 @@ func (m *MsgUpdateNonBtcRelayersResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgUpdateNonBtcRelayersResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgSubmitFeeRateResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgUpdateNonBtcRelayersResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgSubmitFeeRateResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -3425,7 +4321,7 @@ func (m *MsgUpdateNonBtcRelayersResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgSubmitDepositTransaction) Unmarshal(dAtA []byte) error { +func (m *MsgUpdateTrustedNonBtcRelayers) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3448,10 +4344,10 @@ func (m *MsgSubmitDepositTransaction) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgSubmitDepositTransaction: wiretype end group for non-group") + return fmt.Errorf("proto: MsgUpdateTrustedNonBtcRelayers: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgSubmitDepositTransaction: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgUpdateTrustedNonBtcRelayers: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -3488,103 +4384,7 @@ func (m *MsgSubmitDepositTransaction) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Blockhash", 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.Blockhash = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PrevTxBytes", 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.PrevTxBytes = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TxBytes", 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.TxBytes = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Relayers", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -3612,7 +4412,7 @@ func (m *MsgSubmitDepositTransaction) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Proof = append(m.Proof, string(dAtA[iNdEx:postIndex])) + m.Relayers = append(m.Relayers, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex @@ -3635,7 +4435,7 @@ func (m *MsgSubmitDepositTransaction) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgSubmitDepositTransactionResponse) Unmarshal(dAtA []byte) error { +func (m *MsgUpdateTrustedNonBtcRelayersResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3658,10 +4458,10 @@ func (m *MsgSubmitDepositTransactionResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgSubmitDepositTransactionResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgUpdateTrustedNonBtcRelayersResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgSubmitDepositTransactionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgUpdateTrustedNonBtcRelayersResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -3685,7 +4485,7 @@ func (m *MsgSubmitDepositTransactionResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgSubmitWithdrawTransaction) Unmarshal(dAtA []byte) error { +func (m *MsgUpdateTrustedOracles) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3708,10 +4508,10 @@ func (m *MsgSubmitWithdrawTransaction) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgSubmitWithdrawTransaction: wiretype end group for non-group") + return fmt.Errorf("proto: MsgUpdateTrustedOracles: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgSubmitWithdrawTransaction: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgUpdateTrustedOracles: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -3748,71 +4548,7 @@ func (m *MsgSubmitWithdrawTransaction) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Blockhash", 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.Blockhash = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TxBytes", 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.TxBytes = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Oracles", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -3840,7 +4576,7 @@ func (m *MsgSubmitWithdrawTransaction) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Proof = append(m.Proof, string(dAtA[iNdEx:postIndex])) + m.Oracles = append(m.Oracles, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex @@ -3863,7 +4599,7 @@ func (m *MsgSubmitWithdrawTransaction) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgSubmitWithdrawTransactionResponse) Unmarshal(dAtA []byte) error { +func (m *MsgUpdateTrustedOraclesResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3886,10 +4622,10 @@ func (m *MsgSubmitWithdrawTransactionResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgSubmitWithdrawTransactionResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgUpdateTrustedOraclesResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgSubmitWithdrawTransactionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgUpdateTrustedOraclesResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -4006,38 +4742,6 @@ func (m *MsgWithdrawToBitcoin) Unmarshal(dAtA []byte) error { } m.Amount = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FeeRate", 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.FeeRate = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:])