From 0a9d506b890252456435a3e5f728e60ee542b4b6 Mon Sep 17 00:00:00 2001 From: Tanmay Date: Mon, 16 Oct 2023 17:49:17 -0400 Subject: [PATCH 1/2] feat: tss funds migration (#1143) --- app/app.go | 7 +- common/commands.go | 3 +- docs/openapi/openapi.swagger.yaml | 7 + docs/spec/crosschain/messages.md | 10 + proto/crosschain/query.proto | 4 +- proto/crosschain/tx.proto | 11 + testutil/keeper/keeper.go | 24 +- testutil/simapp/simapp.go | 8 +- x/crosschain/client/cli/cli_cctx.go | 31 + x/crosschain/client/cli/cli_chain_nonce.go | 26 + x/crosschain/client/cli/cli_tss.go | 30 + x/crosschain/client/cli/query.go | 2 + .../client/cli/query_get_tss_address.go | 12 +- x/crosschain/client/cli/tx.go | 1 + .../keeper/grpc_query_get_tss_address.go | 23 +- x/crosschain/keeper/msg_migrate_tss_funds.go | 140 ++++ x/crosschain/types/errors.go | 1 + .../types/messages_migrate_tss_funds.go | 54 ++ .../types/messages_migrate_tss_funds_test.go | 59 ++ x/crosschain/types/query.pb.go | 422 ++++++------ x/crosschain/types/query.pb.gw.go | 18 + x/crosschain/types/tx.pb.go | 626 +++++++++++++++--- x/emissions/client/cli/query.go | 3 +- x/emissions/client/cli/tx.go | 3 +- .../client/tests/observer_rewards_test.go | 34 +- .../grpc_query_show_available_emissions.go | 2 +- x/emissions/keeper/keeper.go | 2 +- x/emissions/module.go | 12 +- x/emissions/types/events.pb.go | 4 +- zetaclient/bitcoin_client.go | 11 +- zetaclient/btc_signer.go | 4 +- zetaclient/config/config_mainnet.go | 1 + zetaclient/config/config_mock_mainnet.go | 1 + zetaclient/config/config_privnet.go | 1 + zetaclient/config/config_testnet.go | 1 + zetaclient/evm_signer.go | 35 +- 36 files changed, 1269 insertions(+), 364 deletions(-) create mode 100644 x/crosschain/keeper/msg_migrate_tss_funds.go create mode 100644 x/crosschain/types/messages_migrate_tss_funds.go create mode 100644 x/crosschain/types/messages_migrate_tss_funds_test.go diff --git a/app/app.go b/app/app.go index 53bfee51cd..fdcd402ed8 100644 --- a/app/app.go +++ b/app/app.go @@ -9,6 +9,9 @@ import ( "github.com/gorilla/mux" "github.com/rakyll/statik/fs" "github.com/spf13/cast" + emissionsModule "github.com/zeta-chain/zetacore/x/emissions" + emissionsModuleKeeper "github.com/zeta-chain/zetacore/x/emissions/keeper" + emissionsModuleTypes "github.com/zeta-chain/zetacore/x/emissions/types" "github.com/cosmos/cosmos-sdk/baseapp" "github.com/cosmos/cosmos-sdk/client" @@ -97,10 +100,6 @@ import ( zetaCoreModuleKeeper "github.com/zeta-chain/zetacore/x/crosschain/keeper" zetaCoreModuleTypes "github.com/zeta-chain/zetacore/x/crosschain/types" - emissionsModule "github.com/zeta-chain/zetacore/x/emissions" - emissionsModuleKeeper "github.com/zeta-chain/zetacore/x/emissions/keeper" - emissionsModuleTypes "github.com/zeta-chain/zetacore/x/emissions/types" - fungibleModule "github.com/zeta-chain/zetacore/x/fungible" fungibleModuleKeeper "github.com/zeta-chain/zetacore/x/fungible/keeper" fungibleModuleTypes "github.com/zeta-chain/zetacore/x/fungible/types" diff --git a/common/commands.go b/common/commands.go index d177f499f5..eb51797c3d 100644 --- a/common/commands.go +++ b/common/commands.go @@ -3,5 +3,6 @@ package common // commands for the zetaclient; mostly administrative commands/txs const ( - CmdWhitelistERC20 = "cmd_whitelist_erc20" + CmdWhitelistERC20 = "cmd_whitelist_erc20" + CmdMigrateTssFunds = "cmd_migrate_tss_funds" ) diff --git a/docs/openapi/openapi.swagger.yaml b/docs/openapi/openapi.swagger.yaml index 6e3026b4a7..ae13471986 100644 --- a/docs/openapi/openapi.swagger.yaml +++ b/docs/openapi/openapi.swagger.yaml @@ -26841,6 +26841,11 @@ paths: description: An unexpected error response. schema: $ref: '#/definitions/googlerpcStatus' + parameters: + - name: tss_pub_key + in: query + required: false + type: string tags: - Query /zeta-chain/crosschain/in_tx_hash_to_cctx_data/{inTxHash}: @@ -50519,6 +50524,8 @@ definitions: type: object crosschainMsgGasPriceVoterResponse: type: object + crosschainMsgMigrateTssFundsResponse: + type: object crosschainMsgNonceVoterResponse: type: object crosschainMsgRemoveFromOutTxTrackerResponse: diff --git a/docs/spec/crosschain/messages.md b/docs/spec/crosschain/messages.md index 43a8678e41..a42024e82e 100644 --- a/docs/spec/crosschain/messages.md +++ b/docs/spec/crosschain/messages.md @@ -231,3 +231,13 @@ message MsgUpdateTssAddress { } ``` +## MsgMigrateTssFunds + +```proto +message MsgMigrateTssFunds { + string creator = 1; + int64 chain_id = 2; + string amount = 3; +} +``` + diff --git a/proto/crosschain/query.proto b/proto/crosschain/query.proto index d68192bc7b..9f2c035a4c 100644 --- a/proto/crosschain/query.proto +++ b/proto/crosschain/query.proto @@ -205,7 +205,9 @@ message QueryAllInTxHashToCctxResponse { cosmos.base.query.v1beta1.PageResponse pagination = 2; } -message QueryGetTssAddressRequest {} +message QueryGetTssAddressRequest { + string tss_pub_key = 1; +} message QueryGetTssAddressResponse { string eth = 1; diff --git a/proto/crosschain/tx.proto b/proto/crosschain/tx.proto index 51826c92bc..2e3b3a63a6 100644 --- a/proto/crosschain/tx.proto +++ b/proto/crosschain/tx.proto @@ -17,9 +17,20 @@ service Msg { rpc VoteOnObservedInboundTx(MsgVoteOnObservedInboundTx) returns (MsgVoteOnObservedInboundTxResponse); rpc WhitelistERC20(MsgWhitelistERC20) returns (MsgWhitelistERC20Response); rpc UpdateTssAddress(MsgUpdateTssAddress) returns (MsgUpdateTssAddressResponse); + rpc MigrateTssFunds(MsgMigrateTssFunds) returns (MsgMigrateTssFundsResponse); // rpc ProveOutboundTx(MsgProveOutboundTx) returns (MsgProveOutboundTxResponse); } +message MsgMigrateTssFunds { + string creator = 1; + int64 chain_id = 2; + string amount = 3 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Uint", + (gogoproto.nullable) = false + ]; +} +message MsgMigrateTssFundsResponse {} + message MsgUpdateTssAddress { string creator = 1; string tss_pubkey = 2; diff --git a/testutil/keeper/keeper.go b/testutil/keeper/keeper.go index 316dc4c598..2868f86941 100644 --- a/testutil/keeper/keeper.go +++ b/testutil/keeper/keeper.go @@ -40,7 +40,7 @@ import ( crosschaintypes "github.com/zeta-chain/zetacore/x/crosschain/types" emissionsmodule "github.com/zeta-chain/zetacore/x/emissions" emissionskeeper "github.com/zeta-chain/zetacore/x/emissions/keeper" - emissionstypes "github.com/zeta-chain/zetacore/x/emissions/types" + types2 "github.com/zeta-chain/zetacore/x/emissions/types" fungiblemodule "github.com/zeta-chain/zetacore/x/fungible" fungiblekeeper "github.com/zeta-chain/zetacore/x/fungible/keeper" fungibletypes "github.com/zeta-chain/zetacore/x/fungible/types" @@ -94,16 +94,16 @@ type ZetaKeepers struct { } var moduleAccountPerms = map[string][]string{ - authtypes.FeeCollectorName: nil, - distrtypes.ModuleName: nil, - stakingtypes.BondedPoolName: {authtypes.Burner, authtypes.Staking}, - stakingtypes.NotBondedPoolName: {authtypes.Burner, authtypes.Staking}, - evmtypes.ModuleName: {authtypes.Minter, authtypes.Burner}, - crosschaintypes.ModuleName: {authtypes.Minter, authtypes.Burner}, - fungibletypes.ModuleName: {authtypes.Minter, authtypes.Burner}, - emissionstypes.ModuleName: nil, - emissionstypes.UndistributedObserverRewardsPool: nil, - emissionstypes.UndistributedTssRewardsPool: nil, + authtypes.FeeCollectorName: nil, + distrtypes.ModuleName: nil, + stakingtypes.BondedPoolName: {authtypes.Burner, authtypes.Staking}, + stakingtypes.NotBondedPoolName: {authtypes.Burner, authtypes.Staking}, + evmtypes.ModuleName: {authtypes.Minter, authtypes.Burner}, + crosschaintypes.ModuleName: {authtypes.Minter, authtypes.Burner}, + fungibletypes.ModuleName: {authtypes.Minter, authtypes.Burner}, + types2.ModuleName: nil, + types2.UndistributedObserverRewardsPool: nil, + types2.UndistributedTssRewardsPool: nil, } // ModuleAccountAddrs returns all the app's module account addresses. @@ -363,7 +363,7 @@ func (zk ZetaKeepers) InitGenesis(ctx sdk.Context) { crosschainmodule.InitGenesis(ctx, *zk.CrosschainKeeper, *crosschaintypes.DefaultGenesis()) } if zk.EmissionsKeeper != nil { - emissionsmodule.InitGenesis(ctx, *zk.EmissionsKeeper, *emissionstypes.DefaultGenesis()) + emissionsmodule.InitGenesis(ctx, *zk.EmissionsKeeper, *types2.DefaultGenesis()) } if zk.FungibleKeeper != nil { fungiblemodule.InitGenesis(ctx, *zk.FungibleKeeper, *fungibletypes.DefaultGenesis()) diff --git a/testutil/simapp/simapp.go b/testutil/simapp/simapp.go index 698af75a72..cde89abbab 100644 --- a/testutil/simapp/simapp.go +++ b/testutil/simapp/simapp.go @@ -16,7 +16,7 @@ import ( tmproto "github.com/tendermint/tendermint/proto/tendermint/types" tmtypes "github.com/tendermint/tendermint/types" "github.com/zeta-chain/zetacore/cmd/zetacored/config" - emissionsModuleTypes "github.com/zeta-chain/zetacore/x/emissions/types" + types2 "github.com/zeta-chain/zetacore/x/emissions/types" //"github.com/ignite-hq/cli/ignite/pkg/cosmoscmd" abci "github.com/tendermint/tendermint/abci/types" @@ -58,7 +58,7 @@ func setup(withGenesis bool, invCheckPeriod uint) (*app.App, app.GenesisState) { return a, app.GenesisState{} } -func SetupWithGenesisValSet(t *testing.T, valSet *tmtypes.ValidatorSet, genDelAccs []authtypes.GenesisAccount, bondAmt sdk.Int, emissionParams emissionsModuleTypes.Params, genDelBalances []banktypes.Balance, genBalances []banktypes.Balance) *app.App { +func SetupWithGenesisValSet(t *testing.T, valSet *tmtypes.ValidatorSet, genDelAccs []authtypes.GenesisAccount, bondAmt sdk.Int, emissionParams types2.Params, genDelBalances []banktypes.Balance, genBalances []banktypes.Balance) *app.App { app, genesisState := setup(true, 5) // set genesis accounts authGenesis := authtypes.NewGenesisState(authtypes.DefaultParams(), genDelAccs) @@ -90,9 +90,9 @@ func SetupWithGenesisValSet(t *testing.T, valSet *tmtypes.ValidatorSet, genDelAc delegations = append(delegations, stakingtypes.NewDelegation(genDelAccs[0].GetAddress(), val.Address.Bytes(), sdk.OneDec())) } - emissionsGenesis := emissionsModuleTypes.DefaultGenesis() + emissionsGenesis := types2.DefaultGenesis() emissionsGenesis.Params = emissionParams - genesisState[emissionsModuleTypes.ModuleName] = app.AppCodec().MustMarshalJSON(emissionsGenesis) + genesisState[types2.ModuleName] = app.AppCodec().MustMarshalJSON(emissionsGenesis) // set validators and delegations params := stakingtypes.DefaultParams() params.BondDenom = config.BaseDenom diff --git a/x/crosschain/client/cli/cli_cctx.go b/x/crosschain/client/cli/cli_cctx.go index 058233bb77..070764ca44 100644 --- a/x/crosschain/client/cli/cli_cctx.go +++ b/x/crosschain/client/cli/cli_cctx.go @@ -49,6 +49,37 @@ func CmdListSend() *cobra.Command { return cmd } +func CmdPendingCctx() *cobra.Command { + cmd := &cobra.Command{ + Use: "list-pending-cctx [chain-id]", + Short: "shows pending CCTX", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx := client.GetClientContextFromCmd(cmd) + + queryClient := types.NewQueryClient(clientCtx) + chainID, err := strconv.ParseInt(args[0], 10, 64) + if err != nil { + return err + } + params := &types.QueryAllCctxPendingRequest{ + ChainId: chainID, + } + + res, err := queryClient.CctxAllPending(context.Background(), params) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} + func CmdShowSend() *cobra.Command { cmd := &cobra.Command{ Use: "show-cctx [index]", diff --git a/x/crosschain/client/cli/cli_chain_nonce.go b/x/crosschain/client/cli/cli_chain_nonce.go index dd1ddb2b0d..b5d1dec101 100644 --- a/x/crosschain/client/cli/cli_chain_nonce.go +++ b/x/crosschain/client/cli/cli_chain_nonce.go @@ -72,6 +72,32 @@ func CmdShowChainNonces() *cobra.Command { return cmd } +func CmdListPendingNonces() *cobra.Command { + cmd := &cobra.Command{ + Use: "list-pending-nonces", + Short: "shows a chainNonces", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx := client.GetClientContextFromCmd(cmd) + + queryClient := types.NewQueryClient(clientCtx) + + params := &types.QueryAllPendingNoncesRequest{} + + res, err := queryClient.PendingNoncesAll(context.Background(), params) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} + // Transaction CLI ///////////////////////// func CmdNonceVoter() *cobra.Command { diff --git a/x/crosschain/client/cli/cli_tss.go b/x/crosschain/client/cli/cli_tss.go index f3bc6f18f7..0dd93a244c 100644 --- a/x/crosschain/client/cli/cli_tss.go +++ b/x/crosschain/client/cli/cli_tss.go @@ -5,6 +5,7 @@ import ( "fmt" "strconv" + "cosmossdk.io/math" "github.com/cosmos/cosmos-sdk/client/tx" "github.com/spf13/cast" "github.com/zeta-chain/zetacore/common" @@ -137,3 +138,32 @@ func CmdUpdateTss() *cobra.Command { flags.AddTxFlagsToCmd(cmd) return cmd } + +func CmdMigrateTssFunds() *cobra.Command { + cmd := &cobra.Command{ + Use: "migrate-tss-funds [chainID] [amount]", + Short: "Migrate TSS funds to the latest TSS address", + Args: cobra.ExactArgs(2), + RunE: func(cmd *cobra.Command, args []string) error { + + argsChainID, err := strconv.ParseInt(args[0], 10, 64) + if err != nil { + return err + } + argsAmount := math.NewUintFromString(args[1]) + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + msg := types.NewMsgMigrateTssFunds(clientCtx.GetFromAddress().String(), argsChainID, argsAmount) + if err := msg.ValidateBasic(); err != nil { + return err + } + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + return cmd +} diff --git a/x/crosschain/client/cli/query.go b/x/crosschain/client/cli/query.go index c87c38771c..fe4ac3dc4c 100644 --- a/x/crosschain/client/cli/query.go +++ b/x/crosschain/client/cli/query.go @@ -42,6 +42,8 @@ func GetQueryCmd(_ string) *cobra.Command { CmdQueryParams(), CmdGetTssAddress(), CmdListTssHistory(), + CmdListPendingNonces(), + CmdPendingCctx(), ) return cmd diff --git a/x/crosschain/client/cli/query_get_tss_address.go b/x/crosschain/client/cli/query_get_tss_address.go index 3c95d715cc..785dd05a03 100644 --- a/x/crosschain/client/cli/query_get_tss_address.go +++ b/x/crosschain/client/cli/query_get_tss_address.go @@ -9,19 +9,25 @@ import ( func CmdGetTssAddress() *cobra.Command { cmd := &cobra.Command{ - Use: "get-tss-address", + Use: "get-tss-address [tss-pubkey]", Short: "Query current tss address", - Args: cobra.NoArgs, + Args: cobra.MaximumNArgs(1), RunE: func(cmd *cobra.Command, args []string) (err error) { clientCtx, err := client.GetClientTxContext(cmd) if err != nil { return err } + tssPubKey := "" + if len(args) == 1 { + tssPubKey = args[0] + } queryClient := types.NewQueryClient(clientCtx) - params := &types.QueryGetTssAddressRequest{} + params := &types.QueryGetTssAddressRequest{ + TssPubKey: tssPubKey, + } res, err := queryClient.GetTssAddress(cmd.Context(), params) if err != nil { diff --git a/x/crosschain/client/cli/tx.go b/x/crosschain/client/cli/tx.go index 67e68c59f7..27a0c03af8 100644 --- a/x/crosschain/client/cli/tx.go +++ b/x/crosschain/client/cli/tx.go @@ -29,6 +29,7 @@ func GetTxCmd() *cobra.Command { CmdCCTXInboundVoter(), CmdRemoveFromWatchList(), CmdUpdateTss(), + CmdMigrateTssFunds(), ) return cmd diff --git a/x/crosschain/keeper/grpc_query_get_tss_address.go b/x/crosschain/keeper/grpc_query_get_tss_address.go index e7f5001361..6d21719388 100644 --- a/x/crosschain/keeper/grpc_query_get_tss_address.go +++ b/x/crosschain/keeper/grpc_query_get_tss_address.go @@ -21,16 +21,27 @@ func (k Keeper) GetTssAddress(goCtx context.Context, req *types.QueryGetTssAddre } ctx := sdk.UnwrapSDKContext(goCtx) - - tss, found := k.GetTSS(ctx) - if !found { - return nil, status.Error(codes.NotFound, "not found") + var tssPubKey string + if req.TssPubKey == "" { + tss, found := k.GetTSS(ctx) + if !found { + return nil, status.Error(codes.NotFound, "current tss not set") + } + tssPubKey = tss.TssPubkey + } else { + tssList := k.GetAllTSS(ctx) + for _, t := range tssList { + if t.TssPubkey == req.TssPubKey { + tssPubKey = t.TssPubkey + break + } + } } - ethAddress, err := getTssAddrEVM(tss.TssPubkey) + ethAddress, err := getTssAddrEVM(tssPubKey) if err != nil { return nil, status.Error(codes.Internal, err.Error()) } - btcAddress, err := getTssAddrBTC(tss.TssPubkey) + btcAddress, err := getTssAddrBTC(tssPubKey) if err != nil { return nil, status.Error(codes.Internal, err.Error()) } diff --git a/x/crosschain/keeper/msg_migrate_tss_funds.go b/x/crosschain/keeper/msg_migrate_tss_funds.go new file mode 100644 index 0000000000..85107860dc --- /dev/null +++ b/x/crosschain/keeper/msg_migrate_tss_funds.go @@ -0,0 +1,140 @@ +package keeper + +import ( + "context" + "fmt" + "sort" + + errorsmod "cosmossdk.io/errors" + sdkmath "cosmossdk.io/math" + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/ethereum/go-ethereum/crypto" + tmbytes "github.com/tendermint/tendermint/libs/bytes" + tmtypes "github.com/tendermint/tendermint/types" + "github.com/zeta-chain/zetacore/common" + "github.com/zeta-chain/zetacore/x/crosschain/types" + observerTypes "github.com/zeta-chain/zetacore/x/observer/types" +) + +func (k msgServer) MigrateTssFunds(goCtx context.Context, msg *types.MsgMigrateTssFunds) (*types.MsgMigrateTssFundsResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + if msg.Creator != k.zetaObserverKeeper.GetParams(ctx).GetAdminPolicyAccount(observerTypes.Policy_Type_group2) { + return nil, errorsmod.Wrap(sdkerrors.ErrUnauthorized, "Update can only be executed by the correct policy account") + } + if k.zetaObserverKeeper.IsInboundEnabled(ctx) { + return nil, errorsmod.Wrap(types.ErrUnableToUpdateTss, "cannot migrate funds while inbound is enabled") + } + tss, found := k.GetTSS(ctx) + if !found { + return nil, errorsmod.Wrap(types.ErrUnableToUpdateTss, "cannot find current TSS") + } + pendingNonces, found := k.GetPendingNonces(ctx, tss.TssPubkey, msg.ChainId) + if !found { + return nil, errorsmod.Wrap(types.ErrUnableToUpdateTss, "cannot find pending nonces for chain") + } + if pendingNonces.NonceLow != pendingNonces.NonceHigh { + return nil, errorsmod.Wrap(types.ErrUnableToUpdateTss, "cannot migrate funds when there are pending nonces") + } + err := k.MigrateTSSFundsForChain(ctx, msg.ChainId, msg.Amount, tss) + if err != nil { + return nil, errorsmod.Wrap(types.ErrUnableToUpdateTss, err.Error()) + } + return &types.MsgMigrateTssFundsResponse{}, nil +} + +func (k Keeper) MigrateTSSFundsForChain(ctx sdk.Context, chainID int64, amount sdkmath.Uint, currentTss types.TSS) error { + tssList := k.GetAllTSS(ctx) + if len(tssList) < 2 { + return errorsmod.Wrap(types.ErrCannotMigrateTss, "only one TSS found") + } + // Sort tssList by FinalizedZetaHeight + sort.SliceStable(tssList, func(i, j int) bool { + return tssList[i].FinalizedZetaHeight < tssList[j].FinalizedZetaHeight + }) + // Always migrate to the latest TSS if multiple TSS addresses have been generated + newTss := tssList[len(tssList)-1] + ethAddressOld, err := getTssAddrEVM(currentTss.TssPubkey) + if err != nil { + return err + } + btcAddressOld, err := getTssAddrBTC(currentTss.TssPubkey) + if err != nil { + return err + } + ethAddressNew, err := getTssAddrEVM(newTss.TssPubkey) + if err != nil { + return err + } + btcAddressNew, err := getTssAddrBTC(newTss.TssPubkey) + if err != nil { + return err + } + + medianGasPrice, isFound := k.GetMedianGasPriceInUint(ctx, chainID) + if !isFound { + return types.ErrUnableToGetGasPrice + } + indexString := fmt.Sprintf("%s-%s-%d-%s-%d", currentTss.TssPubkey, newTss.TssPubkey, chainID, amount.String(), ctx.BlockHeight()) + + hash := crypto.Keccak256Hash([]byte(indexString)) + index := hash.Hex() + + cctx := types.CrossChainTx{ + Creator: "", + Index: index, + ZetaFees: sdkmath.Uint{}, + RelayedMessage: fmt.Sprintf("%s:%s", common.CmdMigrateTssFunds, "Funds Migrator Admin Cmd"), + CctxStatus: &types.Status{ + Status: types.CctxStatus_PendingOutbound, + StatusMessage: "", + LastUpdateTimestamp: 0, + }, + InboundTxParams: &types.InboundTxParams{ + Sender: "", + SenderChainId: chainID, + TxOrigin: "", + CoinType: common.CoinType_Cmd, + Asset: "", + Amount: amount, + InboundTxObservedHash: tmbytes.HexBytes(tmtypes.Tx(ctx.TxBytes()).Hash()).String(), + InboundTxObservedExternalHeight: 0, + InboundTxBallotIndex: "", + InboundTxFinalizedZetaHeight: 0, + }, + OutboundTxParams: []*types.OutboundTxParams{{ + Receiver: "", + ReceiverChainId: chainID, + CoinType: common.CoinType_Cmd, + Amount: amount, + OutboundTxTssNonce: 0, + OutboundTxGasLimit: 1_000_000, + OutboundTxGasPrice: medianGasPrice.MulUint64(2).String(), + OutboundTxHash: "", + OutboundTxBallotIndex: "", + OutboundTxObservedExternalHeight: 0, + OutboundTxGasUsed: 0, + OutboundTxEffectiveGasPrice: sdkmath.Int{}, + OutboundTxEffectiveGasLimit: 0, + TssPubkey: currentTss.TssPubkey, + }}} + + if common.IsEVMChain(chainID) { + cctx.InboundTxParams.Sender = ethAddressOld.String() + cctx.GetCurrentOutTxParam().Receiver = ethAddressNew.String() + } + if common.IsBitcoinChain(chainID) { + cctx.InboundTxParams.Sender = btcAddressOld + cctx.GetCurrentOutTxParam().Receiver = btcAddressNew + } + if cctx.GetCurrentOutTxParam().Receiver == "" { + return errorsmod.Wrap(types.ErrCannotMigrateTss, fmt.Sprintf("chain %d is not supported", chainID)) + } + err = k.UpdateNonce(ctx, chainID, &cctx) + if err != nil { + return err + } + k.SetCctxAndNonceToCctxAndInTxHashToCctx(ctx, cctx) + EmitEventInboundFinalized(ctx, &cctx) + return nil +} diff --git a/x/crosschain/types/errors.go b/x/crosschain/types/errors.go index da0674b5c3..32d07bc636 100644 --- a/x/crosschain/types/errors.go +++ b/x/crosschain/types/errors.go @@ -38,4 +38,5 @@ var ( ErrInvalidGasAmount = errorsmod.Register(ModuleName, 1137, "invalid gas amount") ErrNoLiquidityPool = errorsmod.Register(ModuleName, 1138, "no liquidity pool") ErrInvalidCoinType = errorsmod.Register(ModuleName, 1139, "invalid coin type") + ErrCannotMigrateTss = errorsmod.Register(ModuleName, 1140, "Cannot migrate TSS funds") ) diff --git a/x/crosschain/types/messages_migrate_tss_funds.go b/x/crosschain/types/messages_migrate_tss_funds.go new file mode 100644 index 0000000000..b667f4192c --- /dev/null +++ b/x/crosschain/types/messages_migrate_tss_funds.go @@ -0,0 +1,54 @@ +package types + +import ( + errorsmod "cosmossdk.io/errors" + sdkmath "cosmossdk.io/math" + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/zeta-chain/zetacore/common" +) + +var _ sdk.Msg = &MsgMigrateTssFunds{} + +func NewMsgMigrateTssFunds(creator string, chainID int64, amount sdkmath.Uint) *MsgMigrateTssFunds { + return &MsgMigrateTssFunds{ + Creator: creator, + ChainId: chainID, + Amount: amount, + } +} + +func (msg *MsgMigrateTssFunds) Route() string { + return RouterKey +} + +func (msg *MsgMigrateTssFunds) Type() string { + return "MigrateTssFunds" +} + +func (msg *MsgMigrateTssFunds) GetSigners() []sdk.AccAddress { + creator, err := sdk.AccAddressFromBech32(msg.Creator) + if err != nil { + panic(err) + } + return []sdk.AccAddress{creator} +} + +func (msg *MsgMigrateTssFunds) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +func (msg *MsgMigrateTssFunds) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Creator) + if err != nil { + return errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + } + if common.GetChainFromChainID(msg.ChainId) == nil { + return errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "invalid chain id (%d)", msg.ChainId) + } + if msg.Amount.IsZero() { + return errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "amount cannot be zero") + } + return nil +} diff --git a/x/crosschain/types/messages_migrate_tss_funds_test.go b/x/crosschain/types/messages_migrate_tss_funds_test.go new file mode 100644 index 0000000000..bde8ebf02d --- /dev/null +++ b/x/crosschain/types/messages_migrate_tss_funds_test.go @@ -0,0 +1,59 @@ +package types_test + +import ( + "testing" + + sdkmath "cosmossdk.io/math" + "github.com/stretchr/testify/require" + "github.com/zeta-chain/zetacore/common" + "github.com/zeta-chain/zetacore/x/crosschain/types" + observerTypes "github.com/zeta-chain/zetacore/x/observer/types" +) + +func TestNewMsgMigrateTssFunds(t *testing.T) { + tests := []struct { + name string + msg types.MsgMigrateTssFunds + error bool + }{ + { + name: "invalid creator", + msg: types.MsgMigrateTssFunds{ + Creator: "invalid_address", + ChainId: common.GoerliChain().ChainId, + Amount: sdkmath.NewUintFromString("100000"), + }, + error: true, + }, + { + name: "invalid chain id", + msg: types.MsgMigrateTssFunds{ + Creator: "zeta15ruj2tc76pnj9xtw64utktee7cc7w6vzaes73z", + ChainId: 999, + Amount: sdkmath.NewUintFromString("100000"), + }, + error: true, + }, + { + name: "valid msg", + msg: types.MsgMigrateTssFunds{ + Creator: "zeta15ruj2tc76pnj9xtw64utktee7cc7w6vzaes73z", + ChainId: common.GoerliChain().ChainId, + Amount: sdkmath.NewUintFromString("100000"), + }, + error: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + observerTypes.SetConfig(false) + err := tt.msg.ValidateBasic() + if tt.error { + require.Error(t, err) + return + } else { + require.NoError(t, err) + } + }) + } +} diff --git a/x/crosschain/types/query.pb.go b/x/crosschain/types/query.pb.go index 793173dd20..dfeacc4365 100644 --- a/x/crosschain/types/query.pb.go +++ b/x/crosschain/types/query.pb.go @@ -763,6 +763,7 @@ func (m *QueryAllInTxHashToCctxResponse) GetPagination() *query.PageResponse { } type QueryGetTssAddressRequest struct { + TssPubKey string `protobuf:"bytes,1,opt,name=tss_pub_key,json=tssPubKey,proto3" json:"tss_pub_key,omitempty"` } func (m *QueryGetTssAddressRequest) Reset() { *m = QueryGetTssAddressRequest{} } @@ -798,6 +799,13 @@ func (m *QueryGetTssAddressRequest) XXX_DiscardUnknown() { var xxx_messageInfo_QueryGetTssAddressRequest proto.InternalMessageInfo +func (m *QueryGetTssAddressRequest) GetTssPubKey() string { + if m != nil { + return m.TssPubKey + } + return "" +} + type QueryGetTssAddressResponse struct { Eth string `protobuf:"bytes,1,opt,name=eth,proto3" json:"eth,omitempty"` Btc string `protobuf:"bytes,2,opt,name=btc,proto3" json:"btc,omitempty"` @@ -3077,196 +3085,197 @@ func init() { func init() { proto.RegisterFile("crosschain/query.proto", fileDescriptor_65a992045e92a606) } var fileDescriptor_65a992045e92a606 = []byte{ - // 3016 bytes of a gzipped FileDescriptorProto + // 3038 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5a, 0xdd, 0x6f, 0x1b, 0xc7, 0x11, 0xf7, 0x89, 0xfa, 0x5c, 0x7d, 0x7a, 0xad, 0x38, 0x0c, 0x63, 0x8b, 0xce, 0x39, 0xfe, 0x88, - 0x3f, 0xc8, 0x58, 0xb1, 0x95, 0xc4, 0x76, 0xd2, 0x48, 0x76, 0xac, 0x18, 0x51, 0x12, 0xf5, 0xa4, - 0xf4, 0xc3, 0x45, 0x4b, 0x9c, 0x8e, 0x6b, 0xea, 0x90, 0x23, 0x8f, 0xb9, 0x5d, 0x0a, 0x52, 0x0c, + 0x3f, 0xc8, 0x58, 0xb1, 0x9d, 0xc4, 0x76, 0xd2, 0x48, 0x76, 0xac, 0x18, 0x51, 0x12, 0xf5, 0xa4, + 0xf4, 0xc3, 0x45, 0x4b, 0x9c, 0x8e, 0x6b, 0xea, 0xe0, 0x23, 0x8f, 0xb9, 0x5d, 0x0a, 0x52, 0x0c, 0xb5, 0x40, 0xfe, 0x82, 0x00, 0x05, 0xda, 0x97, 0xbe, 0xf6, 0xe3, 0xa1, 0x0f, 0x01, 0x1a, 0x34, - 0x05, 0x0a, 0xa4, 0x0f, 0x6d, 0xd3, 0x3c, 0x06, 0x2d, 0x50, 0xb4, 0x28, 0x40, 0x14, 0x49, 0x9f, + 0x05, 0x0a, 0xa4, 0x0f, 0x6d, 0xd3, 0x3c, 0x06, 0x2d, 0x50, 0xb4, 0x28, 0x40, 0x14, 0x71, 0x9f, 0xf8, 0x1f, 0x14, 0xe8, 0x43, 0xb1, 0x73, 0x73, 0xbc, 0x3d, 0xf2, 0x4e, 0x3c, 0x51, 0x6c, 0xd1, - 0xbe, 0x88, 0xbb, 0xb3, 0x3b, 0xb3, 0xbf, 0x99, 0x9d, 0xd9, 0x9d, 0xbd, 0x11, 0x39, 0x69, 0x79, - 0x2e, 0xe7, 0xd6, 0xb6, 0x69, 0xd7, 0x8a, 0xef, 0x36, 0x98, 0xb7, 0x57, 0xa8, 0x7b, 0xae, 0x70, - 0xe9, 0xe9, 0xf7, 0x98, 0x30, 0x81, 0x5c, 0x80, 0x96, 0xeb, 0xb1, 0x42, 0x38, 0x35, 0x77, 0xc9, - 0x72, 0x79, 0xd5, 0xe5, 0xc5, 0x2d, 0x93, 0x33, 0x9f, 0xaf, 0xb8, 0x73, 0x6d, 0x8b, 0x09, 0xf3, - 0x5a, 0xb1, 0x6e, 0x56, 0xec, 0x9a, 0x29, 0x6c, 0xb7, 0xe6, 0x8b, 0xca, 0x9d, 0x56, 0x96, 0x80, + 0xbe, 0x88, 0xbb, 0xb3, 0x3b, 0xb3, 0xbf, 0x99, 0x9d, 0xd9, 0x9d, 0xbd, 0x11, 0x39, 0x6e, 0x79, + 0x2e, 0xe7, 0xd6, 0x96, 0x69, 0xd7, 0x8a, 0xef, 0x35, 0x98, 0xb7, 0x5b, 0xa8, 0x7b, 0xae, 0x70, + 0xe9, 0xc9, 0xf7, 0x99, 0x30, 0x81, 0x5c, 0x80, 0x96, 0xeb, 0xb1, 0x42, 0x38, 0x35, 0x77, 0xc1, + 0x72, 0x79, 0xd5, 0xe5, 0xc5, 0x4d, 0x93, 0x33, 0x9f, 0xaf, 0xb8, 0x7d, 0x65, 0x93, 0x09, 0xf3, + 0x4a, 0xb1, 0x6e, 0x56, 0xec, 0x9a, 0x29, 0x6c, 0xb7, 0xe6, 0x8b, 0xca, 0x9d, 0x54, 0x96, 0x80, 0xbf, 0xa5, 0x9a, 0x5b, 0xb3, 0x18, 0xc7, 0xe1, 0xbc, 0x3a, 0x2c, 0x9b, 0x25, 0x7f, 0x92, 0xd8, - 0xc5, 0x09, 0x39, 0x65, 0x42, 0xc5, 0xe4, 0xa5, 0xba, 0x67, 0x5b, 0x0c, 0xc7, 0xce, 0x2a, 0x63, - 0xc0, 0x53, 0xda, 0x36, 0xf9, 0x76, 0x49, 0xb8, 0x25, 0xcb, 0x6a, 0x0b, 0xd0, 0x95, 0x49, 0x8e, - 0xc9, 0x45, 0x69, 0xcb, 0x71, 0xad, 0x77, 0x4a, 0xdb, 0xcc, 0xae, 0x6c, 0x0b, 0x9c, 0xb3, 0xa0, - 0xcc, 0x01, 0x78, 0x1d, 0x32, 0x54, 0x94, 0x6e, 0x43, 0xc8, 0x95, 0x84, 0x67, 0x5a, 0xef, 0x30, - 0x0f, 0x27, 0x3c, 0xae, 0x4c, 0xa8, 0x9b, 0x9e, 0x59, 0x0d, 0xf4, 0x9b, 0x57, 0x06, 0x04, 0x6f, - 0x53, 0x2b, 0x6e, 0xc5, 0x85, 0x66, 0x51, 0xb6, 0x90, 0x7a, 0xaa, 0xe2, 0xba, 0x15, 0x87, 0x15, - 0xcd, 0xba, 0x5d, 0x34, 0x6b, 0x35, 0x57, 0x80, 0x1d, 0x91, 0x47, 0xcf, 0x92, 0x93, 0x5f, 0x95, - 0xa6, 0xde, 0xe4, 0xfc, 0x35, 0x9b, 0x0b, 0xd7, 0xdb, 0x33, 0xd8, 0xbb, 0x0d, 0xc6, 0x85, 0xfe, - 0x1d, 0xf2, 0x78, 0xd7, 0x08, 0xaf, 0xbb, 0x35, 0xce, 0xe8, 0x1d, 0x32, 0x2e, 0x38, 0x2f, 0x39, - 0x36, 0x17, 0x59, 0xed, 0x4c, 0xe6, 0xe2, 0xe4, 0xa2, 0x5e, 0x38, 0x70, 0x6f, 0x0b, 0x9b, 0x1b, - 0x1b, 0x2b, 0xc3, 0x9f, 0x35, 0xf3, 0xc7, 0x8c, 0x31, 0xc1, 0xf9, 0x9a, 0xcd, 0x85, 0x3e, 0x4f, - 0x28, 0xc8, 0x5f, 0x07, 0xc5, 0x82, 0x55, 0x1f, 0x90, 0x13, 0x11, 0x6a, 0x7b, 0xc5, 0x51, 0xdf, - 0x00, 0x59, 0xed, 0x8c, 0x76, 0x71, 0x72, 0xf1, 0x5c, 0x8f, 0xf5, 0x7c, 0x76, 0x5c, 0x12, 0x59, - 0xf5, 0x37, 0xc8, 0x93, 0x20, 0x7b, 0x95, 0x89, 0xb7, 0x1a, 0x62, 0x73, 0x77, 0xd3, 0x37, 0x36, - 0x2e, 0x4d, 0xb3, 0x64, 0x0c, 0x98, 0xef, 0xdf, 0x85, 0x45, 0x32, 0x46, 0xd0, 0xa5, 0xf3, 0x64, - 0x04, 0xf6, 0x2f, 0x3b, 0x74, 0x46, 0xbb, 0x38, 0x6c, 0xf8, 0x1d, 0xbd, 0x41, 0x4e, 0xc5, 0x8b, - 0x43, 0xcc, 0x6f, 0x93, 0x29, 0x57, 0xa1, 0x23, 0xf2, 0xcb, 0x3d, 0x90, 0xab, 0xa2, 0x10, 0x7f, - 0x44, 0x8c, 0xce, 0x50, 0x8b, 0x65, 0xc7, 0x89, 0xd3, 0xe2, 0x1e, 0x21, 0x61, 0xb4, 0xe0, 0x9a, - 0xe7, 0x0b, 0x7e, 0x68, 0x15, 0x64, 0x68, 0x15, 0xfc, 0x90, 0xc4, 0xd0, 0x2a, 0xac, 0x9b, 0x15, - 0x86, 0xbc, 0x86, 0xc2, 0xa9, 0x7f, 0xa2, 0xa1, 0x7a, 0x5d, 0xeb, 0x24, 0xaa, 0x97, 0x19, 0x80, - 0x7a, 0x74, 0x35, 0x82, 0x7f, 0x08, 0xf0, 0x5f, 0xe8, 0x89, 0xdf, 0xc7, 0x14, 0x51, 0xe0, 0x7d, - 0x8d, 0xe8, 0x71, 0x0a, 0xac, 0xec, 0xdd, 0x91, 0x48, 0x02, 0x7b, 0xcd, 0x93, 0x11, 0x40, 0x86, - 0x7b, 0xee, 0x77, 0x3a, 0xac, 0x38, 0xd4, 0xb7, 0x15, 0x7f, 0xaf, 0x91, 0xb3, 0x07, 0x82, 0xf8, - 0x3f, 0x31, 0xe6, 0x2d, 0x72, 0x3a, 0xf0, 0xf5, 0xfb, 0xb5, 0xcd, 0xdd, 0xd7, 0x4c, 0xbe, 0xbd, - 0xe9, 0xde, 0xb1, 0xc4, 0x6e, 0x60, 0xc6, 0x1c, 0x19, 0xb7, 0x71, 0x00, 0x2c, 0x39, 0x61, 0xb4, - 0xfb, 0xfa, 0x3e, 0x59, 0x48, 0x62, 0x46, 0xf5, 0xbf, 0x45, 0x66, 0xec, 0xc8, 0x08, 0x3a, 0xee, - 0xd5, 0x1e, 0x06, 0x88, 0x8a, 0x43, 0x13, 0x74, 0x88, 0xd2, 0x6f, 0xe3, 0xf2, 0xd1, 0xc9, 0x77, - 0x4d, 0x61, 0xa6, 0x01, 0xff, 0x1e, 0xc9, 0x27, 0x72, 0x23, 0xfa, 0xaf, 0x93, 0xe9, 0x3b, 0x12, - 0x13, 0x6c, 0xe9, 0xe6, 0x2e, 0x4f, 0xb9, 0x7b, 0x2a, 0x0f, 0x42, 0x8f, 0xca, 0xd1, 0x2b, 0x68, - 0xf5, 0x65, 0xc7, 0x89, 0xb7, 0xfa, 0xa0, 0x82, 0xfd, 0x53, 0x0d, 0x6d, 0x14, 0xb3, 0xd2, 0x01, - 0x5b, 0x94, 0x19, 0xd0, 0x16, 0x0d, 0xce, 0x4f, 0x9f, 0x24, 0x4f, 0x04, 0xae, 0xb6, 0xc9, 0xf9, - 0x72, 0xb9, 0xec, 0x31, 0xde, 0xbe, 0x5b, 0x5e, 0x21, 0xb9, 0xb8, 0x41, 0x54, 0x70, 0x8e, 0x64, - 0x98, 0x08, 0xf6, 0x5f, 0x36, 0x25, 0x65, 0x4b, 0x58, 0x00, 0x67, 0xc2, 0x90, 0xcd, 0xf6, 0x9d, - 0x25, 0x25, 0x6c, 0x6c, 0x04, 0x72, 0x5f, 0xc7, 0x3b, 0x2b, 0xa0, 0xa2, 0xc0, 0xeb, 0x24, 0xb3, - 0xb9, 0xb1, 0x81, 0xbb, 0x92, 0xe2, 0x82, 0x34, 0xe4, 0x74, 0xbd, 0x88, 0xd7, 0xee, 0x2a, 0x13, - 0xab, 0x26, 0x5f, 0x97, 0x79, 0x89, 0x72, 0x54, 0xd9, 0xb5, 0x32, 0xdb, 0x45, 0x8c, 0x7e, 0x47, - 0x2f, 0x91, 0x6c, 0x37, 0x43, 0x78, 0x51, 0x07, 0x34, 0xc4, 0x71, 0xa1, 0x07, 0x8e, 0xb6, 0x88, - 0x36, 0xa3, 0x6e, 0x22, 0xa2, 0x65, 0xc7, 0xe9, 0x44, 0x34, 0x28, 0xff, 0xfb, 0x99, 0x86, 0x4a, - 0x44, 0xd6, 0x88, 0x55, 0x22, 0xd3, 0x97, 0x12, 0x83, 0xf3, 0xb0, 0xc5, 0xd0, 0x89, 0x20, 0x4e, - 0xdf, 0x84, 0xbc, 0xf3, 0xe0, 0x2d, 0x7a, 0x27, 0x4c, 0x3c, 0x22, 0x3c, 0xa8, 0xe0, 0x1a, 0x99, - 0x54, 0xc8, 0x68, 0xc6, 0x4b, 0xbd, 0x4e, 0x0f, 0x45, 0x90, 0xca, 0xae, 0x97, 0x11, 0xe0, 0xb2, - 0xe3, 0xc4, 0x00, 0x1c, 0xd4, 0x8e, 0x7d, 0xa4, 0x85, 0x69, 0x48, 0x2a, 0x9d, 0x32, 0x47, 0xd0, - 0x69, 0x70, 0xbb, 0xb7, 0x10, 0x26, 0x35, 0xeb, 0xac, 0x56, 0xb6, 0x6b, 0x95, 0x88, 0x79, 0x74, - 0x11, 0x9e, 0xb8, 0x1d, 0xe3, 0xa8, 0xd7, 0x06, 0x99, 0xa9, 0xfb, 0x03, 0xf8, 0xe2, 0x40, 0xd5, - 0xae, 0xf4, 0x4a, 0x48, 0x23, 0xd2, 0xa6, 0xeb, 0x6a, 0x57, 0x7f, 0x89, 0x9c, 0xf1, 0x93, 0x5e, - 0x95, 0xda, 0x91, 0xa7, 0x3c, 0x41, 0xc6, 0xfd, 0x37, 0x8c, 0x5d, 0x8e, 0xa6, 0xa7, 0x65, 0xfd, - 0xbb, 0xe4, 0xa9, 0x03, 0xd8, 0x11, 0xf8, 0x37, 0x63, 0x80, 0x6b, 0x87, 0x05, 0x1e, 0x5c, 0x53, - 0x51, 0xf8, 0x4b, 0xe1, 0xfd, 0xbe, 0x66, 0x72, 0xb1, 0x22, 0x5f, 0x42, 0xaf, 0xc1, 0x43, 0xe8, - 0xe0, 0xb0, 0x78, 0x84, 0x57, 0x6b, 0x1c, 0x1f, 0xa2, 0xfe, 0x06, 0x99, 0xed, 0x18, 0x42, 0xd8, - 0x85, 0x1e, 0xb0, 0x3b, 0x05, 0x76, 0x8a, 0xd1, 0xb7, 0xc3, 0x1b, 0x2f, 0x01, 0xf4, 0xa0, 0x42, - 0xe5, 0x77, 0x1a, 0xea, 0x19, 0xb7, 0xd4, 0x41, 0x7a, 0x66, 0x06, 0xa0, 0xe7, 0xe0, 0x42, 0xe7, - 0x72, 0x78, 0xcb, 0xa9, 0x29, 0x48, 0xfc, 0xd6, 0xae, 0x29, 0xa7, 0xa4, 0xbc, 0xf6, 0xf7, 0xc0, - 0x55, 0xfa, 0x7d, 0x69, 0x55, 0xc8, 0x7c, 0x74, 0x69, 0xb4, 0xda, 0x5b, 0x64, 0x4a, 0x4d, 0x98, - 0x52, 0xbe, 0xb0, 0x54, 0x16, 0x23, 0x22, 0x40, 0xff, 0x36, 0xea, 0x28, 0x0f, 0xb5, 0xff, 0x40, - 0x9a, 0xf5, 0xa1, 0x86, 0x8a, 0xb4, 0xe5, 0x27, 0x2a, 0x92, 0x39, 0x92, 0x22, 0x83, 0xdb, 0xf5, - 0xef, 0x29, 0xb7, 0x89, 0x25, 0x76, 0xf1, 0x34, 0xe8, 0x7d, 0x28, 0x0d, 0xec, 0x05, 0xf5, 0xb1, - 0x7a, 0xd1, 0xa8, 0x08, 0xfe, 0xe7, 0x4d, 0x77, 0x0a, 0x4d, 0x27, 0x23, 0xf2, 0x01, 0x13, 0x66, - 0xe4, 0x74, 0xd1, 0x6f, 0xa0, 0x5a, 0x9d, 0xa3, 0xa8, 0xd6, 0x49, 0x32, 0xaa, 0x9c, 0x77, 0x19, - 0x03, 0x7b, 0xfa, 0x26, 0x5e, 0x60, 0x77, 0xdc, 0xda, 0x0e, 0xf3, 0x64, 0xc6, 0xb7, 0xe9, 0x4a, - 0xf6, 0xae, 0xd0, 0xea, 0xda, 0x90, 0x1c, 0x19, 0xaf, 0x98, 0x7c, 0xcd, 0xae, 0xda, 0x02, 0x53, - 0xda, 0x76, 0x5f, 0xff, 0xb1, 0x86, 0xf7, 0x5e, 0xb7, 0x58, 0xc4, 0x73, 0x85, 0x1c, 0x77, 0x1b, - 0x62, 0xcb, 0x6d, 0xd4, 0xca, 0xab, 0x26, 0xbf, 0x5f, 0x93, 0x83, 0x18, 0xf2, 0xdd, 0x03, 0x72, - 0x36, 0x7c, 0x5e, 0xb2, 0x5c, 0xe7, 0x1e, 0x63, 0x38, 0xdb, 0x5f, 0xb4, 0x7b, 0x80, 0x5e, 0x24, - 0xb3, 0xf2, 0x57, 0x3d, 0xfc, 0x32, 0x10, 0xfe, 0x9d, 0x64, 0xfd, 0x02, 0x39, 0x07, 0x30, 0xdf, - 0x60, 0x9c, 0x9b, 0x15, 0xb6, 0x6e, 0x72, 0x6e, 0xd7, 0x2a, 0xeb, 0xa1, 0xc4, 0xc0, 0xba, 0xf7, - 0xc8, 0xf9, 0x5e, 0x13, 0x51, 0xb1, 0x53, 0x64, 0xe2, 0x61, 0x1b, 0xa2, 0xaf, 0x50, 0x48, 0xd0, - 0x6f, 0xe1, 0x82, 0x0f, 0x5e, 0xfd, 0xda, 0x1b, 0x32, 0xbd, 0xf7, 0xcc, 0x1a, 0x37, 0x2d, 0xb9, - 0xbd, 0x06, 0xb3, 0x98, 0x5d, 0x6f, 0x5f, 0x16, 0x94, 0x0c, 0x6f, 0x87, 0xcf, 0x47, 0x68, 0xeb, - 0xff, 0x1a, 0x46, 0x14, 0x07, 0x70, 0xb7, 0xcd, 0x4b, 0xf0, 0x03, 0x62, 0x5b, 0xc8, 0xca, 0x74, - 0xab, 0x99, 0x9f, 0x00, 0xaa, 0x7c, 0x29, 0x19, 0x61, 0x93, 0x2e, 0x92, 0x29, 0x7f, 0x76, 0xad, - 0x51, 0xdd, 0x62, 0x9e, 0x6f, 0xd9, 0x95, 0xd9, 0x56, 0x33, 0x3f, 0x09, 0xf4, 0x37, 0x81, 0x6c, - 0xa8, 0x1d, 0xfa, 0x32, 0x99, 0xb3, 0xdc, 0x9a, 0xf0, 0x4c, 0x4b, 0x94, 0x4c, 0xff, 0xe9, 0x03, - 0x56, 0x9e, 0x58, 0x39, 0xd1, 0x6a, 0xe6, 0x67, 0x83, 0xb1, 0xe0, 0x55, 0xd4, 0x49, 0xa0, 0xaf, - 0x92, 0x13, 0x56, 0xa3, 0xda, 0x70, 0x4c, 0x61, 0xef, 0xb0, 0x52, 0xc5, 0xe4, 0xa5, 0x06, 0x67, - 0xe5, 0xec, 0x30, 0x88, 0x78, 0xac, 0xd5, 0xcc, 0x1f, 0x0f, 0x87, 0x57, 0x4d, 0xfe, 0x36, 0x67, - 0x65, 0xa3, 0x9b, 0x44, 0x4f, 0x91, 0xe1, 0x87, 0x9e, 0x5b, 0xcd, 0x8e, 0x00, 0xdf, 0x78, 0xab, - 0x99, 0x87, 0xbe, 0x01, 0x7f, 0xe9, 0x79, 0xf0, 0x51, 0x5f, 0xf2, 0x28, 0xcc, 0x98, 0x6c, 0x35, - 0xf3, 0x63, 0x15, 0x94, 0x17, 0x34, 0xa4, 0xb9, 0x1c, 0xb7, 0xc2, 0x4b, 0x5b, 0x8e, 0xeb, 0x56, - 0xb3, 0x63, 0xa1, 0xb9, 0x24, 0x75, 0x45, 0x12, 0x8d, 0xb0, 0x49, 0x75, 0x32, 0xca, 0x85, 0x29, - 0x1a, 0x3c, 0x3b, 0x0e, 0x33, 0x49, 0xab, 0x99, 0x47, 0x8a, 0x81, 0xbf, 0xf4, 0x24, 0x19, 0x12, - 0x6e, 0x76, 0x02, 0xc6, 0x47, 0x5b, 0xcd, 0xfc, 0x90, 0x70, 0x8d, 0x21, 0xe1, 0x4a, 0xb3, 0x89, - 0x70, 0xdb, 0xfc, 0xed, 0x21, 0xa1, 0xd9, 0x94, 0x31, 0xd8, 0xa4, 0x4e, 0x02, 0x5d, 0x26, 0xc7, - 0x55, 0x7e, 0xff, 0xaa, 0x9c, 0x04, 0x01, 0xf3, 0xad, 0x66, 0x5e, 0x15, 0x7e, 0x5f, 0x8e, 0x19, - 0x5d, 0x14, 0xba, 0x44, 0x86, 0xa5, 0x2e, 0xd9, 0xa9, 0x54, 0x5f, 0x5a, 0xd7, 0xdc, 0x8a, 0x01, - 0xf3, 0xf5, 0xf7, 0x33, 0x24, 0xb3, 0xe6, 0x56, 0xe4, 0x91, 0x10, 0x6c, 0xb8, 0xef, 0x9d, 0x41, - 0x57, 0x1e, 0x32, 0xc2, 0xad, 0xdb, 0x16, 0xcf, 0x0e, 0x9d, 0xc9, 0x5c, 0x9c, 0x30, 0xb0, 0x27, - 0x9d, 0xb9, 0x6c, 0x0a, 0xd3, 0xf7, 0x0f, 0x03, 0xda, 0x5d, 0x3e, 0x27, 0x37, 0x7e, 0xb8, 0xb7, - 0xcf, 0x75, 0x19, 0x6f, 0xe4, 0xa8, 0xc6, 0x1b, 0x85, 0x85, 0xd3, 0x1a, 0x2f, 0x1a, 0x58, 0x63, - 0x3d, 0x02, 0xeb, 0x19, 0x22, 0xdd, 0x06, 0x17, 0x1a, 0x87, 0x85, 0xa6, 0x5a, 0xcd, 0xfc, 0xb8, - 0xe3, 0x56, 0xfc, 0x05, 0xda, 0x2d, 0x7a, 0x8e, 0x8c, 0x79, 0xac, 0xea, 0xee, 0xb0, 0x32, 0x78, - 0xcd, 0xb8, 0xef, 0xa9, 0x48, 0x32, 0x82, 0x86, 0x7e, 0x1d, 0xd3, 0xcc, 0xb8, 0x23, 0x20, 0xf9, - 0xe4, 0xf8, 0xe7, 0x30, 0xa6, 0x8c, 0x71, 0x6c, 0xff, 0xb5, 0x23, 0x23, 0x88, 0xd5, 0x4c, 0x6c, - 0xac, 0x3e, 0x41, 0x32, 0x15, 0x93, 0xe3, 0x01, 0x30, 0xd6, 0x6a, 0xe6, 0x65, 0xd7, 0x90, 0x7f, - 0xa4, 0x19, 0xdb, 0x45, 0x15, 0xdc, 0x70, 0x30, 0x63, 0xa5, 0xfd, 0x2e, 0x0f, 0x5a, 0x72, 0x0d, - 0xc0, 0x3f, 0x1a, 0xae, 0x21, 0xfb, 0xbe, 0x1d, 0x68, 0x5e, 0x26, 0x97, 0xf5, 0x86, 0xc0, 0x8d, - 0x9b, 0x68, 0x35, 0xf3, 0x3e, 0xc1, 0xf0, 0x7f, 0xe4, 0x04, 0x3f, 0x5f, 0x1c, 0x0f, 0x27, 0x00, - 0x01, 0x53, 0xc7, 0xc4, 0xb8, 0x8e, 0x75, 0x2d, 0x72, 0xa8, 0xb8, 0xcc, 0x93, 0x91, 0x1d, 0xd3, - 0x69, 0x30, 0x0c, 0x67, 0x58, 0x1b, 0x08, 0x86, 0xff, 0x23, 0x75, 0x13, 0x7b, 0x75, 0x96, 0x9d, - 0x0a, 0x75, 0x93, 0x7d, 0x03, 0xfe, 0xd2, 0x22, 0x99, 0x34, 0x2d, 0x8b, 0x05, 0x75, 0x94, 0x69, - 0x19, 0x81, 0x2b, 0x33, 0xad, 0x66, 0x9e, 0xf8, 0xe4, 0x35, 0x5b, 0x66, 0x42, 0x61, 0x5b, 0x1e, - 0x8e, 0xed, 0x64, 0x6b, 0x26, 0x3c, 0x1c, 0xf1, 0x7e, 0x0f, 0x2f, 0xfa, 0x13, 0x44, 0xdb, 0xc9, - 0xce, 0xc2, 0x84, 0x91, 0x56, 0x33, 0xaf, 0xed, 0x18, 0xda, 0x8e, 0x24, 0x7a, 0xd9, 0xb9, 0x90, - 0xe8, 0x19, 0x9a, 0x27, 0x89, 0x3c, 0x7b, 0x3c, 0x24, 0x72, 0x43, 0xe3, 0xfa, 0x4d, 0x7c, 0x8c, - 0xa2, 0xeb, 0xc1, 0xf5, 0xbb, 0xb2, 0x87, 0xfe, 0x81, 0x3e, 0x7b, 0x92, 0x8c, 0x6e, 0x87, 0xd9, - 0xc9, 0xb0, 0x81, 0x3d, 0xfd, 0xaf, 0x63, 0xf8, 0x14, 0x8d, 0x67, 0x46, 0xcf, 0xd5, 0xc9, 0x28, - 0x7a, 0xa1, 0x16, 0x9e, 0xc7, 0x3e, 0xc5, 0xc0, 0xdf, 0xb6, 0x5f, 0x0c, 0xc5, 0xfa, 0x45, 0x91, - 0x4c, 0xd6, 0x4d, 0x8f, 0xd5, 0x84, 0xef, 0xfc, 0xbe, 0x83, 0x82, 0xed, 0x7c, 0x32, 0x78, 0xbf, - 0xd2, 0x0e, 0xfd, 0x64, 0x38, 0xc1, 0x4f, 0x8a, 0x64, 0x92, 0x6f, 0x9b, 0xcf, 0x95, 0x1a, 0x35, - 0xcb, 0x61, 0x1c, 0x9d, 0x16, 0x24, 0x4a, 0xf2, 0xdb, 0x40, 0x35, 0x94, 0x76, 0xc7, 0x15, 0x34, - 0xda, 0xe3, 0x0a, 0x8a, 0xba, 0x1b, 0x2f, 0x79, 0xae, 0x1b, 0x38, 0x75, 0xa7, 0xbb, 0x71, 0xc3, - 0x75, 0x85, 0xd1, 0x45, 0x91, 0x0b, 0xca, 0xbb, 0x8a, 0xf9, 0xbc, 0xe3, 0xe1, 0x82, 0x40, 0x05, - 0xa6, 0xb0, 0x49, 0x6f, 0x90, 0x69, 0xcf, 0xcf, 0x31, 0x70, 0x31, 0x3f, 0x04, 0xe6, 0x5a, 0xcd, - 0xfc, 0x54, 0x30, 0x00, 0x3c, 0x91, 0x9e, 0xb4, 0x53, 0xd5, 0xae, 0x31, 0x0f, 0x43, 0x01, 0xec, - 0x04, 0x04, 0xc3, 0xff, 0xa1, 0x05, 0x42, 0xca, 0xf6, 0xc3, 0x87, 0xb6, 0xd5, 0x70, 0xc4, 0x1e, - 0x7a, 0x3e, 0x98, 0x29, 0xa4, 0x1a, 0x4a, 0x1b, 0xae, 0x00, 0x57, 0x98, 0x4e, 0x49, 0xe1, 0x9a, - 0x52, 0xae, 0x00, 0x39, 0x76, 0x37, 0x64, 0xed, 0x24, 0x48, 0xad, 0xd9, 0xae, 0xf0, 0xcc, 0x12, - 0x5c, 0x48, 0xd3, 0xa1, 0xd6, 0x40, 0x85, 0xcf, 0xf0, 0x61, 0x53, 0x7a, 0x0d, 0xb7, 0xdf, 0x63, - 0x18, 0x1e, 0xe0, 0x35, 0xb2, 0x6f, 0xc0, 0xdf, 0xe0, 0x58, 0x72, 0x20, 0x05, 0x9e, 0x8d, 0x1c, - 0x4b, 0x90, 0x06, 0x87, 0x09, 0x71, 0x24, 0x11, 0x99, 0x3b, 0x20, 0x11, 0xb9, 0x4c, 0x26, 0x84, - 0x5d, 0x65, 0x5c, 0x98, 0xd5, 0x3a, 0x46, 0x12, 0xa0, 0x6b, 0x13, 0x8d, 0xb0, 0x49, 0xaf, 0x93, - 0x29, 0x75, 0x57, 0xb3, 0x14, 0x42, 0x1e, 0xb6, 0x24, 0xb2, 0xdb, 0x91, 0x9e, 0x8c, 0x16, 0x74, - 0xca, 0x13, 0x30, 0x1f, 0xa2, 0xc5, 0xa7, 0x18, 0xf8, 0x4b, 0x6f, 0x92, 0x39, 0xf9, 0x32, 0x29, - 0x3d, 0x64, 0xac, 0x54, 0x67, 0x9e, 0x4c, 0xcf, 0xb2, 0xf3, 0x80, 0xe6, 0x78, 0xab, 0x99, 0x9f, - 0x96, 0x63, 0xf7, 0x18, 0x5b, 0x67, 0xde, 0xaa, 0xc9, 0x8d, 0x68, 0x57, 0xaa, 0x5a, 0xb5, 0xfd, - 0x1a, 0x77, 0xf6, 0xb1, 0x50, 0xd5, 0xaa, 0x0d, 0x1f, 0xe8, 0x8d, 0xa0, 0xb1, 0xf8, 0xe1, 0xd3, - 0x64, 0x04, 0x62, 0x9b, 0xfe, 0x40, 0x23, 0xa3, 0x7e, 0x81, 0x95, 0x5e, 0xeb, 0x91, 0x8d, 0x74, - 0x57, 0x78, 0x73, 0x8b, 0x87, 0x61, 0xf1, 0x4f, 0x0c, 0xfd, 0xdc, 0xfb, 0x7f, 0xfa, 0xc7, 0xf7, - 0x87, 0xf2, 0xf4, 0x74, 0x51, 0x72, 0x5c, 0x55, 0x0a, 0xfb, 0x6a, 0x71, 0x9c, 0x7e, 0xaa, 0x91, - 0x29, 0xb5, 0x26, 0x46, 0x6f, 0xa6, 0x59, 0x2b, 0xbe, 0x1c, 0x9c, 0xbb, 0xd5, 0x17, 0x2f, 0x02, - 0x7e, 0x09, 0x00, 0x3f, 0x4f, 0x6f, 0x24, 0x00, 0x56, 0xab, 0x74, 0xc5, 0x47, 0xf8, 0xf5, 0x63, - 0xbf, 0xf8, 0x08, 0x0e, 0xa3, 0x7d, 0xfa, 0xb1, 0x46, 0x66, 0x55, 0xb9, 0xcb, 0x8e, 0x93, 0x4e, - 0x97, 0xf8, 0xa2, 0x70, 0x3a, 0x5d, 0x12, 0x0a, 0xbd, 0xfa, 0x65, 0xd0, 0xe5, 0x1c, 0x3d, 0x9b, - 0x42, 0x17, 0xfa, 0x37, 0x8d, 0x9c, 0xec, 0x40, 0x8e, 0x5f, 0x22, 0xe9, 0x72, 0x1f, 0x20, 0xa2, - 0x1f, 0x41, 0x73, 0x2b, 0x47, 0x11, 0x81, 0xea, 0xdc, 0x04, 0x75, 0xae, 0xd3, 0xc5, 0x14, 0xea, - 0x20, 0x2f, 0xee, 0xd0, 0x3e, 0xfd, 0x83, 0x46, 0x66, 0xa2, 0x05, 0x2d, 0x7a, 0x3b, 0xa5, 0x9b, - 0xc4, 0x16, 0xf0, 0x72, 0x2f, 0xf5, 0xc9, 0x8d, 0xba, 0xbc, 0x00, 0xba, 0x2c, 0xd2, 0x67, 0x13, - 0x74, 0x89, 0x96, 0xd9, 0x8a, 0x8f, 0x82, 0xfe, 0x3e, 0xfd, 0xb3, 0x46, 0x68, 0x77, 0x49, 0x93, - 0xa6, 0xc2, 0x93, 0x58, 0x48, 0xcd, 0xbd, 0xdc, 0x2f, 0x3b, 0xea, 0xb3, 0x0c, 0xfa, 0xdc, 0xa2, - 0x2f, 0x26, 0xea, 0xd3, 0xf9, 0xef, 0x38, 0x70, 0x2f, 0xa8, 0x8a, 0xfd, 0x46, 0x23, 0xc7, 0xa3, - 0x2b, 0xc8, 0xe0, 0xb9, 0x9d, 0xd2, 0x71, 0x8e, 0xb0, 0x4b, 0x89, 0xa5, 0x53, 0xfd, 0x2a, 0x68, - 0x75, 0x81, 0x9e, 0x4b, 0xb5, 0x4b, 0xf4, 0x23, 0x8d, 0x4c, 0x47, 0x4a, 0x94, 0xf4, 0x85, 0x94, - 0x5e, 0xd2, 0x55, 0xf2, 0xcc, 0xbd, 0xd8, 0x07, 0x27, 0xa2, 0x2e, 0x00, 0xea, 0x8b, 0xf4, 0x7c, - 0x02, 0xea, 0x0a, 0x13, 0x25, 0xc1, 0x79, 0xf0, 0x31, 0x81, 0x7e, 0xa0, 0x41, 0xbd, 0x33, 0xdd, - 0x95, 0x10, 0x29, 0xa0, 0xa6, 0xbb, 0x12, 0xa2, 0xd5, 0x55, 0x5d, 0x07, 0x78, 0xa7, 0x68, 0x2e, - 0x01, 0x9e, 0x84, 0xf2, 0x73, 0x2d, 0x2c, 0x1d, 0xd2, 0xa5, 0x94, 0x8b, 0x74, 0xd4, 0x38, 0x73, - 0xcf, 0x1f, 0x9a, 0x0f, 0x11, 0x16, 0x01, 0xe1, 0x33, 0xf4, 0x42, 0x92, 0x01, 0x91, 0x41, 0x7a, - 0x6f, 0x99, 0xed, 0xee, 0xd3, 0x9f, 0x6a, 0x64, 0x32, 0x90, 0x22, 0x9d, 0x76, 0x29, 0xa5, 0xdb, - 0xf5, 0x85, 0x38, 0xa6, 0xd2, 0xaa, 0x5f, 0x00, 0xc4, 0x4f, 0xd1, 0x7c, 0x0f, 0xc4, 0xf4, 0x13, - 0x8d, 0xcc, 0x75, 0x7e, 0x2a, 0xa4, 0xa9, 0x2e, 0x99, 0x84, 0xef, 0x96, 0xb9, 0xdb, 0xfd, 0x31, - 0xa7, 0x34, 0xb5, 0xd5, 0x89, 0xf5, 0x53, 0x8d, 0x4c, 0x2a, 0x5f, 0x03, 0xe9, 0xdd, 0x34, 0xcb, - 0xf7, 0xfa, 0xea, 0x98, 0x7b, 0xf5, 0x88, 0x52, 0x50, 0x9b, 0x4b, 0xa0, 0xcd, 0xd3, 0x54, 0x4f, - 0xca, 0x76, 0x14, 0xe0, 0xbf, 0xd2, 0x22, 0x85, 0x56, 0x9a, 0x36, 0xe0, 0xbb, 0x4b, 0xc3, 0xb9, - 0x9b, 0xfd, 0xb0, 0x22, 0xe4, 0x45, 0x80, 0x7c, 0x85, 0x5e, 0x4a, 0xda, 0x80, 0x90, 0xa7, 0xed, - 0xee, 0xbf, 0xd0, 0xc8, 0x8c, 0x22, 0x4b, 0x7a, 0xfc, 0x8b, 0x29, 0x3d, 0xb7, 0x5f, 0xf4, 0xf1, - 0xc5, 0xea, 0x9e, 0x06, 0x57, 0xd0, 0xd3, 0x5f, 0x6b, 0x64, 0x2e, 0x52, 0x13, 0x95, 0xb8, 0xd3, - 0xe6, 0x57, 0x71, 0x35, 0xe7, 0xdc, 0xed, 0xfe, 0x98, 0x11, 0xfb, 0x15, 0xc0, 0x7e, 0x9e, 0x3e, - 0x9d, 0xe4, 0x2c, 0x2a, 0x17, 0xfd, 0xa3, 0x46, 0xe6, 0xe3, 0xca, 0xc4, 0xf4, 0x2b, 0xa9, 0xb2, - 0xf2, 0xe4, 0xfa, 0x74, 0xee, 0x95, 0xfe, 0x05, 0xa0, 0x26, 0xcf, 0x83, 0x26, 0xd7, 0x68, 0x31, - 0x8d, 0x26, 0x98, 0x92, 0x95, 0xec, 0xf2, 0x3e, 0xfd, 0x4c, 0xeb, 0xaa, 0x9e, 0xd2, 0xb4, 0x89, - 0x55, 0x7c, 0xed, 0x37, 0x5d, 0x22, 0x93, 0x5c, 0xb7, 0xd6, 0x97, 0x40, 0x97, 0x67, 0x69, 0x21, - 0x41, 0x17, 0x27, 0xca, 0xd7, 0x8e, 0x89, 0xdf, 0x6a, 0x84, 0x76, 0xc8, 0x94, 0xfe, 0x95, 0x36, - 0x01, 0x39, 0x8a, 0x36, 0xc9, 0xd5, 0xe9, 0x9e, 0xa9, 0x40, 0x87, 0x36, 0xf4, 0x47, 0x1a, 0x19, - 0x86, 0x54, 0x26, 0xed, 0xc5, 0xae, 0x26, 0x5b, 0xcf, 0x1d, 0x8a, 0x27, 0xe5, 0x1b, 0xc5, 0xc2, - 0xf4, 0x17, 0x8c, 0xfc, 0x91, 0x3c, 0x33, 0xc3, 0xaa, 0x74, 0xfa, 0x33, 0xb3, 0xab, 0x92, 0xdd, - 0x1f, 0xd8, 0x1b, 0x00, 0xb6, 0x48, 0xaf, 0x1e, 0x08, 0xb6, 0xeb, 0x51, 0xf8, 0x43, 0x8d, 0x8c, - 0x05, 0xf9, 0xec, 0x62, 0xda, 0xd3, 0xee, 0xb0, 0x86, 0xed, 0xa8, 0x4c, 0xeb, 0x67, 0x01, 0xeb, - 0x69, 0xfa, 0xe4, 0x01, 0x58, 0xfd, 0x93, 0xdc, 0x47, 0x86, 0x11, 0x9e, 0xfe, 0x24, 0xef, 0x2a, - 0x2a, 0xa7, 0x3f, 0xc9, 0xbb, 0xab, 0xc1, 0xbd, 0x4f, 0xf2, 0x90, 0x87, 0xfe, 0x52, 0x23, 0x33, - 0xd1, 0xea, 0x6b, 0x3a, 0xd4, 0xb1, 0xf5, 0xdc, 0x74, 0xa8, 0xe3, 0x8b, 0xbd, 0x3d, 0x1f, 0x08, - 0x4e, 0x14, 0xe5, 0x4f, 0x34, 0x42, 0xc2, 0xff, 0xca, 0xa7, 0x37, 0xd2, 0xac, 0xdc, 0xf5, 0xff, - 0xfd, 0xb9, 0xa5, 0xc3, 0xb2, 0x21, 0xd8, 0x67, 0x00, 0xec, 0x59, 0xfa, 0x54, 0x02, 0x58, 0xd1, - 0x66, 0x59, 0x79, 0xfd, 0xb3, 0x2f, 0x16, 0xb4, 0xcf, 0xbf, 0x58, 0xd0, 0xfe, 0xfe, 0xc5, 0x82, - 0xf6, 0xc1, 0x97, 0x0b, 0xc7, 0x3e, 0xff, 0x72, 0xe1, 0xd8, 0x5f, 0xbe, 0x5c, 0x38, 0xf6, 0xe0, - 0x5a, 0xc5, 0x16, 0xdb, 0x8d, 0xad, 0x82, 0xe5, 0x56, 0x55, 0x31, 0x01, 0x8e, 0xe2, 0x6e, 0x44, - 0xe2, 0x5e, 0x9d, 0xf1, 0xad, 0x51, 0x48, 0x7b, 0x9e, 0xfb, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, - 0xe5, 0x77, 0xa5, 0xc6, 0x5e, 0x32, 0x00, 0x00, + 0xc1, 0x09, 0x39, 0x65, 0x42, 0xc5, 0xe4, 0xa5, 0xba, 0x67, 0x5b, 0x0c, 0xc7, 0x4e, 0x2b, 0x63, + 0xc0, 0x53, 0xda, 0x32, 0xf9, 0x56, 0x49, 0xb8, 0x25, 0xcb, 0x6a, 0x0b, 0xd0, 0x95, 0x49, 0x8e, + 0xc9, 0x45, 0x69, 0xd3, 0x71, 0xad, 0x87, 0xa5, 0x2d, 0x66, 0x57, 0xb6, 0x04, 0xce, 0x59, 0x50, + 0xe6, 0x00, 0xbc, 0x0e, 0x19, 0x2a, 0x4a, 0xb7, 0x21, 0xe4, 0x4a, 0xc2, 0x33, 0xad, 0x87, 0xcc, + 0xc3, 0x09, 0x4f, 0x2a, 0x13, 0xea, 0xa6, 0x67, 0x56, 0x03, 0xfd, 0xe6, 0x95, 0x01, 0xc1, 0xdb, + 0xd4, 0x8a, 0x5b, 0x71, 0xa1, 0x59, 0x94, 0x2d, 0xa4, 0x9e, 0xa8, 0xb8, 0x6e, 0xc5, 0x61, 0x45, + 0xb3, 0x6e, 0x17, 0xcd, 0x5a, 0xcd, 0x15, 0x60, 0x47, 0xe4, 0xd1, 0xb3, 0xe4, 0xf8, 0x57, 0xa5, + 0xa9, 0x37, 0x38, 0x7f, 0xc3, 0xe6, 0xc2, 0xf5, 0x76, 0x0d, 0xf6, 0x5e, 0x83, 0x71, 0xa1, 0x7f, + 0x87, 0x3c, 0xd9, 0x35, 0xc2, 0xeb, 0x6e, 0x8d, 0x33, 0x7a, 0x9b, 0x8c, 0x0b, 0xce, 0x4b, 0x8e, + 0xcd, 0x45, 0x56, 0x3b, 0x95, 0x39, 0x3f, 0xb9, 0xa8, 0x17, 0xf6, 0xdd, 0xdb, 0xc2, 0xc6, 0xfa, + 0xfa, 0xf2, 0xf0, 0xe7, 0xcd, 0xfc, 0x11, 0x63, 0x4c, 0x70, 0xbe, 0x6a, 0x73, 0xa1, 0xcf, 0x13, + 0x0a, 0xf2, 0xd7, 0x40, 0xb1, 0x60, 0xd5, 0xfb, 0xe4, 0x58, 0x84, 0xda, 0x5e, 0x71, 0xd4, 0x37, + 0x40, 0x56, 0x3b, 0xa5, 0x9d, 0x9f, 0x5c, 0x3c, 0xd3, 0x63, 0x3d, 0x9f, 0x1d, 0x97, 0x44, 0x56, + 0xfd, 0x2d, 0xf2, 0x34, 0xc8, 0x5e, 0x61, 0xe2, 0x9d, 0x86, 0xd8, 0xd8, 0xd9, 0xf0, 0x8d, 0x8d, + 0x4b, 0xd3, 0x2c, 0x19, 0x03, 0xe6, 0x7b, 0x77, 0x60, 0x91, 0x8c, 0x11, 0x74, 0xe9, 0x3c, 0x19, + 0x81, 0xfd, 0xcb, 0x0e, 0x9d, 0xd2, 0xce, 0x0f, 0x1b, 0x7e, 0x47, 0x6f, 0x90, 0x13, 0xf1, 0xe2, + 0x10, 0xf3, 0xbb, 0x64, 0xca, 0x55, 0xe8, 0x88, 0xfc, 0x62, 0x0f, 0xe4, 0xaa, 0x28, 0xc4, 0x1f, + 0x11, 0xa3, 0x33, 0xd4, 0x62, 0xc9, 0x71, 0xe2, 0xb4, 0xb8, 0x4b, 0x48, 0x18, 0x2d, 0xb8, 0xe6, + 0xd9, 0x82, 0x1f, 0x5a, 0x05, 0x19, 0x5a, 0x05, 0x3f, 0x24, 0x31, 0xb4, 0x0a, 0x6b, 0x66, 0x85, + 0x21, 0xaf, 0xa1, 0x70, 0xea, 0x9f, 0x6a, 0xa8, 0x5e, 0xd7, 0x3a, 0x89, 0xea, 0x65, 0x06, 0xa0, + 0x1e, 0x5d, 0x89, 0xe0, 0x1f, 0x02, 0xfc, 0xe7, 0x7a, 0xe2, 0xf7, 0x31, 0x45, 0x14, 0xf8, 0x40, + 0x23, 0x7a, 0x9c, 0x02, 0xcb, 0xbb, 0xb7, 0x25, 0x92, 0xc0, 0x5e, 0xf3, 0x64, 0x04, 0x90, 0xe1, + 0x9e, 0xfb, 0x9d, 0x0e, 0x2b, 0x0e, 0xf5, 0x6d, 0xc5, 0xdf, 0x6b, 0xe4, 0xf4, 0xbe, 0x20, 0xfe, + 0x4f, 0x8c, 0x79, 0x93, 0x9c, 0x0c, 0x7c, 0xfd, 0x5e, 0x6d, 0x63, 0xe7, 0x0d, 0x93, 0x6f, 0x6d, + 0xb8, 0xb7, 0x2d, 0xb1, 0x13, 0x98, 0x31, 0x47, 0xc6, 0x6d, 0x1c, 0x00, 0x4b, 0x4e, 0x18, 0xed, + 0xbe, 0xbe, 0x47, 0x16, 0x92, 0x98, 0x51, 0xfd, 0x6f, 0x91, 0x19, 0x3b, 0x32, 0x82, 0x8e, 0x7b, + 0xb9, 0x87, 0x01, 0xa2, 0xe2, 0xd0, 0x04, 0x1d, 0xa2, 0xf4, 0x5b, 0xb8, 0x7c, 0x74, 0xf2, 0x1d, + 0x53, 0x98, 0x69, 0xc0, 0xbf, 0x4f, 0xf2, 0x89, 0xdc, 0x88, 0xfe, 0xeb, 0x64, 0xfa, 0xb6, 0xc4, + 0x04, 0x5b, 0xba, 0xb1, 0xc3, 0x53, 0xee, 0x9e, 0xca, 0x83, 0xd0, 0xa3, 0x72, 0xf4, 0x0a, 0x5a, + 0x7d, 0xc9, 0x71, 0xe2, 0xad, 0x3e, 0xa8, 0x60, 0xff, 0x4c, 0x43, 0x1b, 0xc5, 0xac, 0xb4, 0xcf, + 0x16, 0x65, 0x06, 0xb4, 0x45, 0x83, 0xf4, 0xd3, 0xa7, 0x02, 0x57, 0xdb, 0xe0, 0x7c, 0xa9, 0x5c, + 0xf6, 0x18, 0x0f, 0xee, 0x16, 0xba, 0x40, 0x26, 0xe5, 0xb5, 0x55, 0x6f, 0x6c, 0x96, 0x1e, 0xb2, + 0x5d, 0xdc, 0xe9, 0x09, 0xc1, 0xf9, 0x5a, 0x63, 0xf3, 0x4d, 0xb6, 0xab, 0xbf, 0x46, 0x72, 0x71, + 0xcc, 0x68, 0x80, 0x39, 0x92, 0x61, 0x22, 0xf0, 0x0f, 0xd9, 0x94, 0x94, 0x4d, 0x61, 0x01, 0xdc, + 0x09, 0x43, 0x36, 0xdb, 0x77, 0x9a, 0x94, 0xb0, 0xbe, 0x1e, 0xdc, 0x69, 0x6f, 0xe2, 0x9d, 0x16, + 0x50, 0x51, 0xe0, 0x55, 0x92, 0xd9, 0x58, 0x5f, 0xc7, 0x5d, 0x4b, 0x71, 0x81, 0x1a, 0x72, 0xba, + 0x5e, 0xc4, 0x6b, 0x79, 0x85, 0x89, 0x15, 0x93, 0xaf, 0xc9, 0xbc, 0x45, 0x39, 0xca, 0xec, 0x5a, + 0x99, 0xed, 0x20, 0x46, 0xbf, 0xa3, 0x97, 0x48, 0xb6, 0x9b, 0x21, 0xbc, 0xc8, 0x03, 0x1a, 0xe2, + 0x38, 0xd7, 0x03, 0x47, 0x5b, 0x44, 0x9b, 0x51, 0x37, 0x11, 0xd1, 0x92, 0xe3, 0x74, 0x22, 0x1a, + 0x94, 0x7f, 0xfe, 0x4c, 0x43, 0x25, 0x22, 0x6b, 0xc4, 0x2a, 0x91, 0xe9, 0x4b, 0x89, 0xc1, 0x79, + 0xe0, 0x62, 0xe8, 0x44, 0x10, 0xc7, 0x6f, 0x43, 0x5e, 0xba, 0xff, 0x16, 0x3d, 0x0c, 0x13, 0x93, + 0x08, 0x0f, 0x2a, 0xb8, 0x4a, 0x26, 0x15, 0x32, 0x9a, 0xf1, 0x42, 0xaf, 0xd3, 0x45, 0x11, 0xa4, + 0xb2, 0xeb, 0x65, 0x04, 0xb8, 0xe4, 0x38, 0x31, 0x00, 0x07, 0xb5, 0x63, 0x1f, 0x6b, 0x61, 0x9a, + 0x92, 0x4a, 0xa7, 0xcc, 0x21, 0x74, 0x1a, 0xdc, 0xee, 0x2d, 0x84, 0x49, 0xcf, 0x1a, 0xab, 0x95, + 0xed, 0x5a, 0x25, 0x62, 0x1e, 0x5d, 0x84, 0x27, 0x72, 0xc7, 0x38, 0xea, 0xb5, 0x4e, 0x66, 0xea, + 0xfe, 0x00, 0xbe, 0x48, 0x50, 0xb5, 0x4b, 0xbd, 0x12, 0xd6, 0x88, 0xb4, 0xe9, 0xba, 0xda, 0xd5, + 0x5f, 0x21, 0xa7, 0xfc, 0xa4, 0x58, 0xa5, 0x76, 0xe4, 0x31, 0x4f, 0x91, 0x71, 0xff, 0x8d, 0x63, + 0x97, 0xa3, 0xe9, 0x6b, 0x59, 0xff, 0x2e, 0x79, 0x66, 0x1f, 0x76, 0x04, 0xfe, 0xcd, 0x18, 0xe0, + 0xda, 0x41, 0x81, 0x07, 0xd7, 0x58, 0x14, 0xfe, 0xf5, 0xf0, 0xfe, 0x5f, 0x35, 0xb9, 0x58, 0x96, + 0x2f, 0xa5, 0x37, 0xe0, 0xa1, 0xb4, 0x7f, 0x58, 0x3c, 0xc2, 0xab, 0x37, 0x8e, 0x0f, 0x51, 0x7f, + 0x83, 0xcc, 0x76, 0x0c, 0x21, 0xec, 0x42, 0x0f, 0xd8, 0x9d, 0x02, 0x3b, 0xc5, 0xe8, 0x5b, 0xe1, + 0x8d, 0x98, 0x00, 0x7a, 0x50, 0xa1, 0xf2, 0x3b, 0x0d, 0xf5, 0x8c, 0x5b, 0x6a, 0x3f, 0x3d, 0x33, + 0x03, 0xd0, 0x73, 0x70, 0xa1, 0x73, 0x31, 0xbc, 0xe5, 0xd4, 0x14, 0x25, 0x7e, 0x6b, 0x57, 0x95, + 0x53, 0x52, 0xa6, 0x05, 0xbb, 0xe0, 0x2a, 0xfd, 0xbe, 0xc4, 0x2a, 0x64, 0x3e, 0xba, 0x34, 0x5a, + 0xed, 0x1d, 0x32, 0xa5, 0x26, 0x54, 0x29, 0x5f, 0x60, 0x2a, 0x8b, 0x11, 0x11, 0xa0, 0x7f, 0x1b, + 0x75, 0x94, 0x87, 0xda, 0x7f, 0x20, 0x0d, 0xfb, 0x48, 0x43, 0x45, 0xda, 0xf2, 0x13, 0x15, 0xc9, + 0x1c, 0x4a, 0x91, 0xc1, 0xed, 0xfa, 0xf7, 0x94, 0xdb, 0xc4, 0x12, 0x3b, 0x78, 0x1a, 0xf4, 0x3e, + 0x94, 0x06, 0xf6, 0xc2, 0xfa, 0x44, 0xbd, 0x68, 0x54, 0x04, 0xff, 0xf3, 0xa6, 0x3b, 0x81, 0xa6, + 0x93, 0x11, 0x79, 0x9f, 0x09, 0x33, 0x72, 0xba, 0xe8, 0xd7, 0x50, 0xad, 0xce, 0x51, 0x54, 0xeb, + 0x38, 0x19, 0x55, 0xce, 0xbb, 0x8c, 0x81, 0x3d, 0x7d, 0x03, 0x2f, 0xb0, 0xdb, 0x6e, 0x6d, 0x9b, + 0x79, 0x32, 0xe3, 0xdb, 0x70, 0x25, 0x7b, 0x57, 0x68, 0x75, 0x6d, 0x48, 0x8e, 0x8c, 0x57, 0x4c, + 0xbe, 0x6a, 0x57, 0x6d, 0x81, 0x29, 0x6d, 0xbb, 0xaf, 0xff, 0x58, 0xc3, 0x7b, 0xaf, 0x5b, 0x2c, + 0xe2, 0xb9, 0x44, 0x8e, 0xba, 0x0d, 0xb1, 0xe9, 0x36, 0x6a, 0xe5, 0x15, 0x93, 0xdf, 0xab, 0xc9, + 0x41, 0x0c, 0xf9, 0xee, 0x01, 0x39, 0x1b, 0x3e, 0x3f, 0x59, 0xae, 0x73, 0x97, 0x31, 0x9c, 0xed, + 0x2f, 0xda, 0x3d, 0x40, 0xcf, 0x93, 0x59, 0xf9, 0xab, 0x1e, 0x7e, 0x19, 0x08, 0xff, 0x4e, 0xb2, + 0x7e, 0x8e, 0x9c, 0x01, 0x98, 0x6f, 0x31, 0xce, 0xcd, 0x0a, 0x5b, 0x33, 0x39, 0xb7, 0x6b, 0x95, + 0xb5, 0x50, 0x62, 0x60, 0xdd, 0xbb, 0xe4, 0x6c, 0xaf, 0x89, 0xa8, 0xd8, 0x09, 0x32, 0xf1, 0xa0, + 0x0d, 0x11, 0x9f, 0x0c, 0x6d, 0x82, 0x7e, 0x13, 0x17, 0xbc, 0xff, 0xfa, 0xd7, 0xde, 0x92, 0xe9, + 0xbd, 0x67, 0xd6, 0xb8, 0x69, 0xc9, 0xed, 0x35, 0x98, 0xc5, 0xec, 0x7a, 0xfb, 0xb2, 0xa0, 0x64, + 0x78, 0x2b, 0x7c, 0x5e, 0x42, 0x5b, 0xff, 0xd7, 0x30, 0xa2, 0xd8, 0x87, 0xbb, 0x6d, 0x5e, 0x82, + 0x1f, 0x18, 0xdb, 0x42, 0x96, 0xa7, 0x5b, 0xcd, 0xfc, 0x04, 0x50, 0xe5, 0x4b, 0xca, 0x08, 0x9b, + 0x74, 0x91, 0x4c, 0xf9, 0xb3, 0x6b, 0x8d, 0xea, 0x26, 0xf3, 0x7c, 0xcb, 0x2e, 0xcf, 0xb6, 0x9a, + 0xf9, 0x49, 0xa0, 0xbf, 0x0d, 0x64, 0x43, 0xed, 0xd0, 0x57, 0xc9, 0x9c, 0xe5, 0xd6, 0x84, 0x67, + 0x5a, 0xa2, 0x64, 0xfa, 0x4f, 0x1f, 0xb0, 0xf2, 0xc4, 0xf2, 0xb1, 0x56, 0x33, 0x3f, 0x1b, 0x8c, + 0x05, 0xaf, 0xa2, 0x4e, 0x02, 0x7d, 0x9d, 0x1c, 0xb3, 0x1a, 0xd5, 0x86, 0x63, 0x0a, 0x7b, 0x9b, + 0x95, 0x2a, 0x26, 0x2f, 0x35, 0x38, 0x2b, 0x67, 0x87, 0x41, 0xc4, 0x13, 0xad, 0x66, 0xfe, 0x68, + 0x38, 0xbc, 0x62, 0xf2, 0x77, 0x39, 0x2b, 0x1b, 0xdd, 0x24, 0x7a, 0x82, 0x0c, 0x3f, 0xf0, 0xdc, + 0x6a, 0x76, 0x04, 0xf8, 0xc6, 0x5b, 0xcd, 0x3c, 0xf4, 0x0d, 0xf8, 0x4b, 0xcf, 0x82, 0x8f, 0xfa, + 0x92, 0x47, 0x61, 0xc6, 0x64, 0xab, 0x99, 0x1f, 0xab, 0xa0, 0xbc, 0xa0, 0x21, 0xcd, 0xe5, 0xb8, + 0x15, 0x5e, 0xda, 0x74, 0x5c, 0xb7, 0x9a, 0x1d, 0x0b, 0xcd, 0x25, 0xa9, 0xcb, 0x92, 0x68, 0x84, + 0x4d, 0xaa, 0x93, 0x51, 0x2e, 0x4c, 0xd1, 0xe0, 0xd9, 0x71, 0x98, 0x49, 0x5a, 0xcd, 0x3c, 0x52, + 0x0c, 0xfc, 0xa5, 0xc7, 0xc9, 0x90, 0x70, 0xb3, 0x13, 0x30, 0x3e, 0xda, 0x6a, 0xe6, 0x87, 0x84, + 0x6b, 0x0c, 0x09, 0x57, 0x9a, 0x4d, 0x84, 0xdb, 0xe6, 0x6f, 0x0f, 0x09, 0xcd, 0xa6, 0x8c, 0xc1, + 0x26, 0x75, 0x12, 0xe8, 0x12, 0x39, 0xaa, 0xf2, 0xfb, 0x57, 0xe5, 0x24, 0x08, 0x98, 0x6f, 0x35, + 0xf3, 0xaa, 0xf0, 0x7b, 0x72, 0xcc, 0xe8, 0xa2, 0xd0, 0xeb, 0x64, 0x58, 0xea, 0x92, 0x9d, 0x4a, + 0xf5, 0x25, 0x76, 0xd5, 0xad, 0x18, 0x30, 0x5f, 0xff, 0x20, 0x43, 0x32, 0xab, 0x6e, 0x45, 0x1e, + 0x09, 0xc1, 0x86, 0xfb, 0xde, 0x19, 0x74, 0xe5, 0x21, 0x23, 0xdc, 0xba, 0x6d, 0xf1, 0xec, 0xd0, + 0xa9, 0xcc, 0xf9, 0x09, 0x03, 0x7b, 0xd2, 0x99, 0xcb, 0xa6, 0x30, 0x7d, 0xff, 0x30, 0xa0, 0xdd, + 0xe5, 0x73, 0x72, 0xe3, 0x87, 0x7b, 0xfb, 0x5c, 0x97, 0xf1, 0x46, 0x0e, 0x6b, 0xbc, 0x51, 0x58, + 0x38, 0xad, 0xf1, 0xa2, 0x81, 0x35, 0xd6, 0x23, 0xb0, 0x9e, 0x23, 0xd2, 0x6d, 0x70, 0xa1, 0x71, + 0x58, 0x68, 0xaa, 0xd5, 0xcc, 0x8f, 0x3b, 0x6e, 0xc5, 0x5f, 0xa0, 0xdd, 0xa2, 0x67, 0xc8, 0x98, + 0xc7, 0xaa, 0xee, 0x36, 0x2b, 0x83, 0xd7, 0x8c, 0xfb, 0x9e, 0x8a, 0x24, 0x23, 0x68, 0xe8, 0x57, + 0x31, 0xcd, 0x8c, 0x3b, 0x02, 0x92, 0x4f, 0x8e, 0x7f, 0x0e, 0x63, 0xca, 0x18, 0xc7, 0xf6, 0x5f, + 0x3b, 0x32, 0x82, 0x58, 0xcd, 0xc4, 0xc6, 0xea, 0x53, 0x24, 0x53, 0x31, 0x39, 0x1e, 0x00, 0x63, + 0xad, 0x66, 0x5e, 0x76, 0x0d, 0xf9, 0x47, 0x9a, 0xb1, 0x5d, 0x74, 0xc1, 0x0d, 0x07, 0x33, 0x56, + 0xda, 0xef, 0xf2, 0xa0, 0x25, 0xd7, 0x00, 0xfc, 0xa3, 0xe1, 0x1a, 0xb2, 0xef, 0xdb, 0x81, 0xe6, + 0x65, 0x72, 0x59, 0x6f, 0x08, 0xdc, 0xb8, 0x89, 0x56, 0x33, 0xef, 0x13, 0x0c, 0xff, 0x47, 0x4e, + 0xf0, 0xf3, 0xc5, 0xf1, 0x70, 0x02, 0x10, 0x30, 0x75, 0x4c, 0x8c, 0xeb, 0x58, 0xd7, 0x22, 0x07, + 0x8a, 0xcb, 0x3c, 0x19, 0xd9, 0x36, 0x9d, 0x06, 0xc3, 0x70, 0x86, 0xb5, 0x81, 0x60, 0xf8, 0x3f, + 0x52, 0x37, 0xb1, 0x5b, 0x67, 0xd9, 0xa9, 0x50, 0x37, 0xd9, 0x37, 0xe0, 0x2f, 0x2d, 0x92, 0x49, + 0xd3, 0xb2, 0x58, 0x50, 0x67, 0x99, 0x96, 0x11, 0xb8, 0x3c, 0xd3, 0x6a, 0xe6, 0x89, 0x4f, 0x5e, + 0xb5, 0x65, 0x26, 0x14, 0xb6, 0xe5, 0xe1, 0xd8, 0x4e, 0xb6, 0x66, 0xc2, 0xc3, 0x11, 0xef, 0xf7, + 0xf0, 0xa2, 0x3f, 0x46, 0xb4, 0xed, 0xec, 0x2c, 0x4c, 0x18, 0x69, 0x35, 0xf3, 0xda, 0xb6, 0xa1, + 0x6d, 0x4b, 0xa2, 0x97, 0x9d, 0x0b, 0x89, 0x9e, 0xa1, 0x79, 0x92, 0xc8, 0xb3, 0x47, 0x43, 0x22, + 0x37, 0x34, 0xae, 0xdf, 0xc0, 0xc7, 0x28, 0xba, 0x1e, 0x5c, 0xbf, 0xcb, 0xbb, 0xe8, 0x1f, 0xe8, + 0xb3, 0xc7, 0xc9, 0xe8, 0x56, 0x98, 0x9d, 0x0c, 0x1b, 0xd8, 0xd3, 0xff, 0x3a, 0x86, 0x4f, 0xd1, + 0x78, 0x66, 0xf4, 0x5c, 0x9d, 0x8c, 0xa2, 0x17, 0x6a, 0xe1, 0x79, 0xec, 0x53, 0x0c, 0xfc, 0x6d, + 0xfb, 0xc5, 0x50, 0xac, 0x5f, 0x14, 0xc9, 0x64, 0xdd, 0xf4, 0x58, 0x4d, 0xf8, 0xce, 0xef, 0x3b, + 0x28, 0xd8, 0xce, 0x27, 0x83, 0xf7, 0x2b, 0xed, 0xd0, 0x4f, 0x86, 0x13, 0xfc, 0xa4, 0x48, 0x26, + 0xf9, 0x96, 0xf9, 0x42, 0xa9, 0x51, 0xb3, 0x1c, 0xc6, 0xd1, 0x69, 0x41, 0xa2, 0x24, 0xbf, 0x0b, + 0x54, 0x43, 0x69, 0x77, 0x5c, 0x41, 0xa3, 0x3d, 0xae, 0xa0, 0xa8, 0xbb, 0xf1, 0x92, 0xe7, 0xba, + 0x81, 0x53, 0x77, 0xba, 0x1b, 0x37, 0x5c, 0x57, 0x18, 0x5d, 0x14, 0xb9, 0xa0, 0xbc, 0xab, 0x98, + 0xcf, 0x3b, 0x1e, 0x2e, 0x08, 0x54, 0x60, 0x0a, 0x9b, 0xf4, 0x1a, 0x99, 0xf6, 0xfc, 0x1c, 0x03, + 0x17, 0xf3, 0x43, 0x60, 0xae, 0xd5, 0xcc, 0x4f, 0x05, 0x03, 0xc0, 0x13, 0xe9, 0x49, 0x3b, 0x55, + 0xed, 0x1a, 0xf3, 0x30, 0x14, 0xc0, 0x4e, 0x40, 0x30, 0xfc, 0x1f, 0x5a, 0x20, 0xa4, 0x6c, 0x3f, + 0x78, 0x60, 0x5b, 0x0d, 0x47, 0xec, 0xa2, 0xe7, 0x83, 0x99, 0x42, 0xaa, 0xa1, 0xb4, 0xe1, 0x0a, + 0x70, 0x85, 0xe9, 0x94, 0x14, 0xae, 0x29, 0xe5, 0x0a, 0x90, 0x63, 0x77, 0x42, 0xd6, 0x4e, 0x82, + 0xd4, 0x9a, 0xed, 0x08, 0xcf, 0x2c, 0xc1, 0x85, 0x34, 0x1d, 0x6a, 0x0d, 0x54, 0xf8, 0x4c, 0x1f, + 0x36, 0xa5, 0xd7, 0x70, 0xfb, 0x7d, 0x86, 0xe1, 0x01, 0x5e, 0x23, 0xfb, 0x06, 0xfc, 0x0d, 0x8e, + 0x25, 0x07, 0x52, 0xe0, 0xd9, 0xc8, 0xb1, 0x04, 0x69, 0x70, 0x98, 0x10, 0x47, 0x12, 0x91, 0xb9, + 0x7d, 0x12, 0x91, 0x8b, 0x64, 0x42, 0xd8, 0x55, 0xc6, 0x85, 0x59, 0xad, 0x63, 0x24, 0x01, 0xba, + 0x36, 0xd1, 0x08, 0x9b, 0xf4, 0x2a, 0x99, 0x52, 0x77, 0x35, 0x4b, 0x21, 0xe4, 0x61, 0x4b, 0x22, + 0xbb, 0x1d, 0xe9, 0xc9, 0x68, 0x41, 0xa7, 0x3c, 0x06, 0xf3, 0x21, 0x5a, 0x7c, 0x8a, 0x81, 0xbf, + 0xf4, 0x06, 0x99, 0x93, 0x2f, 0x93, 0xd2, 0x03, 0xc6, 0x4a, 0x75, 0xe6, 0xc9, 0xf4, 0x2c, 0x3b, + 0x0f, 0x68, 0x8e, 0xb6, 0x9a, 0xf9, 0x69, 0x39, 0x76, 0x97, 0xb1, 0x35, 0xe6, 0xad, 0x98, 0xdc, + 0x88, 0x76, 0xa5, 0xaa, 0x55, 0xdb, 0xaf, 0x81, 0x67, 0x9f, 0x08, 0x55, 0xad, 0xda, 0xf0, 0x01, + 0xdf, 0x08, 0x1a, 0x8b, 0x1f, 0x3d, 0x4b, 0x46, 0x20, 0xb6, 0xe9, 0x0f, 0x34, 0x32, 0xea, 0x17, + 0x60, 0xe9, 0x95, 0x1e, 0xd9, 0x48, 0x77, 0x05, 0x38, 0xb7, 0x78, 0x10, 0x16, 0xff, 0xc4, 0xd0, + 0xcf, 0x7c, 0xf0, 0xa7, 0x7f, 0x7c, 0x7f, 0x28, 0x4f, 0x4f, 0x16, 0x25, 0xc7, 0x65, 0xa5, 0xf0, + 0xaf, 0x16, 0xcf, 0xe9, 0x67, 0x1a, 0x99, 0x52, 0x6b, 0x66, 0xf4, 0x46, 0x9a, 0xb5, 0xe2, 0xcb, + 0xc5, 0xb9, 0x9b, 0x7d, 0xf1, 0x22, 0xe0, 0x57, 0x00, 0xf0, 0x8b, 0xf4, 0x5a, 0x02, 0x60, 0xb5, + 0x8a, 0x57, 0x7c, 0x84, 0x5f, 0x3f, 0xf6, 0x8a, 0x8f, 0xe0, 0x30, 0xda, 0xa3, 0x9f, 0x68, 0x64, + 0x56, 0x95, 0xbb, 0xe4, 0x38, 0xe9, 0x74, 0x89, 0x2f, 0x1a, 0xa7, 0xd3, 0x25, 0xa1, 0x10, 0xac, + 0x5f, 0x04, 0x5d, 0xce, 0xd0, 0xd3, 0x29, 0x74, 0xa1, 0x7f, 0xd3, 0xc8, 0xf1, 0x0e, 0xe4, 0xf8, + 0x25, 0x92, 0x2e, 0xf5, 0x01, 0x22, 0xfa, 0x11, 0x34, 0xb7, 0x7c, 0x18, 0x11, 0xa8, 0xce, 0x0d, + 0x50, 0xe7, 0x2a, 0x5d, 0x4c, 0xa1, 0x0e, 0xf2, 0xe2, 0x0e, 0xed, 0xd1, 0x3f, 0x68, 0x64, 0x26, + 0x5a, 0xf0, 0xa2, 0xb7, 0x52, 0xba, 0x49, 0x6c, 0x81, 0x2f, 0xf7, 0x4a, 0x9f, 0xdc, 0xa8, 0xcb, + 0x4b, 0xa0, 0xcb, 0x22, 0x7d, 0x3e, 0x41, 0x97, 0x68, 0x19, 0xae, 0xf8, 0x28, 0xe8, 0xef, 0xd1, + 0x3f, 0x6b, 0x84, 0x76, 0x97, 0x3c, 0x69, 0x2a, 0x3c, 0x89, 0x85, 0xd6, 0xdc, 0xab, 0xfd, 0xb2, + 0xa3, 0x3e, 0x4b, 0xa0, 0xcf, 0x4d, 0xfa, 0x72, 0xa2, 0x3e, 0x9d, 0xff, 0xae, 0x03, 0xf7, 0x82, + 0xaa, 0xd8, 0x6f, 0x34, 0x72, 0x34, 0xba, 0x82, 0x0c, 0x9e, 0x5b, 0x29, 0x1d, 0xe7, 0x10, 0xbb, + 0x94, 0x58, 0x5a, 0xd5, 0x2f, 0x83, 0x56, 0xe7, 0xe8, 0x99, 0x54, 0xbb, 0x44, 0x3f, 0xd6, 0xc8, + 0x74, 0xa4, 0x44, 0x49, 0x5f, 0x4a, 0xe9, 0x25, 0x5d, 0x25, 0xd1, 0xdc, 0xcb, 0x7d, 0x70, 0x22, + 0xea, 0x02, 0xa0, 0x3e, 0x4f, 0xcf, 0x26, 0xa0, 0xae, 0x30, 0x51, 0x12, 0x9c, 0x07, 0x1f, 0x13, + 0xe8, 0x87, 0x1a, 0xd4, 0x3b, 0xd3, 0x5d, 0x09, 0x91, 0x02, 0x6a, 0xba, 0x2b, 0x21, 0x5a, 0x5d, + 0xd5, 0x75, 0x80, 0x77, 0x82, 0xe6, 0x12, 0xe0, 0x49, 0x28, 0x3f, 0xd7, 0xc2, 0xd2, 0x21, 0xbd, + 0x9e, 0x72, 0x91, 0x8e, 0x1a, 0x67, 0xee, 0xc5, 0x03, 0xf3, 0x21, 0xc2, 0x22, 0x20, 0x7c, 0x8e, + 0x9e, 0x4b, 0x32, 0x20, 0x32, 0x48, 0xef, 0x2d, 0xb3, 0x9d, 0x3d, 0xfa, 0x53, 0x8d, 0x4c, 0x06, + 0x52, 0xa4, 0xd3, 0x5e, 0x4f, 0xe9, 0x76, 0x7d, 0x21, 0x8e, 0xa9, 0xb4, 0xea, 0xe7, 0x00, 0xf1, + 0x33, 0x34, 0xdf, 0x03, 0x31, 0xfd, 0x54, 0x23, 0x73, 0x9d, 0x9f, 0x0a, 0x69, 0xaa, 0x4b, 0x26, + 0xe1, 0xbb, 0x65, 0xee, 0x56, 0x7f, 0xcc, 0x29, 0x4d, 0x6d, 0x75, 0x62, 0xfd, 0x4c, 0x23, 0x93, + 0xca, 0xd7, 0x40, 0x7a, 0x27, 0xcd, 0xf2, 0xbd, 0xbe, 0x3a, 0xe6, 0x5e, 0x3f, 0xa4, 0x14, 0xd4, + 0xe6, 0x02, 0x68, 0xf3, 0x2c, 0xd5, 0x93, 0xb2, 0x1d, 0x05, 0xf8, 0xaf, 0xb4, 0x48, 0xa1, 0x95, + 0xa6, 0x0d, 0xf8, 0xee, 0xd2, 0x70, 0xee, 0x46, 0x3f, 0xac, 0x08, 0x79, 0x11, 0x20, 0x5f, 0xa2, + 0x17, 0x92, 0x36, 0x20, 0xe4, 0x69, 0xbb, 0xfb, 0x2f, 0x34, 0x32, 0xa3, 0xc8, 0x92, 0x1e, 0xff, + 0x72, 0x4a, 0xcf, 0xed, 0x17, 0x7d, 0x7c, 0xb1, 0xba, 0xa7, 0xc1, 0x15, 0xf4, 0xf4, 0xd7, 0x1a, + 0x99, 0x8b, 0xd4, 0x44, 0x25, 0xee, 0xb4, 0xf9, 0x55, 0x5c, 0xcd, 0x39, 0x77, 0xab, 0x3f, 0x66, + 0xc4, 0x7e, 0x09, 0xb0, 0x9f, 0xa5, 0xcf, 0x26, 0x39, 0x8b, 0xca, 0x45, 0xff, 0xa8, 0x91, 0xf9, + 0xb8, 0x32, 0x31, 0xfd, 0x4a, 0xaa, 0xac, 0x3c, 0xb9, 0x3e, 0x9d, 0x7b, 0xad, 0x7f, 0x01, 0xa8, + 0xc9, 0x8b, 0xa0, 0xc9, 0x15, 0x5a, 0x4c, 0xa3, 0x09, 0xa6, 0x64, 0x25, 0xbb, 0xbc, 0x47, 0x3f, + 0xd7, 0xba, 0xaa, 0xa7, 0x34, 0x6d, 0x62, 0x15, 0x5f, 0xfb, 0x4d, 0x97, 0xc8, 0x24, 0xd7, 0xad, + 0xf5, 0xeb, 0xa0, 0xcb, 0xf3, 0xb4, 0x90, 0xa0, 0x8b, 0x13, 0xe5, 0x6b, 0xc7, 0xc4, 0x6f, 0x35, + 0x42, 0x3b, 0x64, 0x4a, 0xff, 0x4a, 0x9b, 0x80, 0x1c, 0x46, 0x9b, 0xe4, 0xea, 0x74, 0xcf, 0x54, + 0xa0, 0x43, 0x1b, 0xfa, 0x23, 0x8d, 0x0c, 0x43, 0x2a, 0x93, 0xf6, 0x62, 0x57, 0x93, 0xad, 0x17, + 0x0e, 0xc4, 0x93, 0xf2, 0x8d, 0x62, 0x61, 0xfa, 0x0b, 0x46, 0xfe, 0x58, 0x9e, 0x99, 0x61, 0x55, + 0x3a, 0xfd, 0x99, 0xd9, 0x55, 0xc9, 0xee, 0x0f, 0xec, 0x35, 0x00, 0x5b, 0xa4, 0x97, 0xf7, 0x05, + 0xdb, 0xf5, 0x28, 0xfc, 0xa1, 0x46, 0xc6, 0x82, 0x7c, 0x76, 0x31, 0xed, 0x69, 0x77, 0x50, 0xc3, + 0x76, 0x54, 0xa6, 0xf5, 0xd3, 0x80, 0xf5, 0x24, 0x7d, 0x7a, 0x1f, 0xac, 0xfe, 0x49, 0xee, 0x23, + 0xc3, 0x08, 0x4f, 0x7f, 0x92, 0x77, 0x15, 0x95, 0xd3, 0x9f, 0xe4, 0xdd, 0xd5, 0xe0, 0xde, 0x27, + 0x79, 0xc8, 0x43, 0x7f, 0xa9, 0x91, 0x99, 0x68, 0xf5, 0x35, 0x1d, 0xea, 0xd8, 0x7a, 0x6e, 0x3a, + 0xd4, 0xf1, 0xc5, 0xde, 0x9e, 0x0f, 0x04, 0x27, 0x8a, 0xf2, 0x27, 0x1a, 0x21, 0xe1, 0x7f, 0xed, + 0xd3, 0x6b, 0x69, 0x56, 0xee, 0xfa, 0xff, 0xff, 0xdc, 0xf5, 0x83, 0xb2, 0x21, 0xd8, 0xe7, 0x00, + 0xec, 0x69, 0xfa, 0x4c, 0x02, 0x58, 0xd1, 0x66, 0x59, 0x7e, 0xf3, 0xf3, 0x2f, 0x17, 0xb4, 0x2f, + 0xbe, 0x5c, 0xd0, 0xfe, 0xfe, 0xe5, 0x82, 0xf6, 0xe1, 0xe3, 0x85, 0x23, 0x5f, 0x3c, 0x5e, 0x38, + 0xf2, 0x97, 0xc7, 0x0b, 0x47, 0xee, 0x5f, 0xa9, 0xd8, 0x62, 0xab, 0xb1, 0x59, 0xb0, 0xdc, 0xaa, + 0x2a, 0x26, 0xc0, 0x51, 0xdc, 0x89, 0x48, 0xdc, 0xad, 0x33, 0xbe, 0x39, 0x0a, 0x69, 0xcf, 0x0b, + 0xff, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xe5, 0x26, 0xeb, 0xed, 0x7e, 0x32, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -4840,6 +4849,13 @@ func (m *QueryGetTssAddressRequest) MarshalToSizedBuffer(dAtA []byte) (int, erro _ = i var l int _ = l + if len(m.TssPubKey) > 0 { + i -= len(m.TssPubKey) + copy(dAtA[i:], m.TssPubKey) + i = encodeVarintQuery(dAtA, i, uint64(len(m.TssPubKey))) + i-- + dAtA[i] = 0xa + } return len(dAtA) - i, nil } @@ -6817,6 +6833,10 @@ func (m *QueryGetTssAddressRequest) Size() (n int) { } var l int _ = l + l = len(m.TssPubKey) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } return n } @@ -9024,6 +9044,38 @@ func (m *QueryGetTssAddressRequest) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: QueryGetTssAddressRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TssPubKey", 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.TssPubKey = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipQuery(dAtA[iNdEx:]) diff --git a/x/crosschain/types/query.pb.gw.go b/x/crosschain/types/query.pb.gw.go index 2f1029d3f6..7832f5170c 100644 --- a/x/crosschain/types/query.pb.gw.go +++ b/x/crosschain/types/query.pb.gw.go @@ -379,10 +379,21 @@ func local_request_Query_InTxHashToCctxAll_0(ctx context.Context, marshaler runt } +var ( + filter_Query_GetTssAddress_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + func request_Query_GetTssAddress_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryGetTssAddressRequest 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_GetTssAddress_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + msg, err := client.GetTssAddress(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err @@ -392,6 +403,13 @@ func local_request_Query_GetTssAddress_0(ctx context.Context, marshaler runtime. var protoReq QueryGetTssAddressRequest 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_GetTssAddress_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + msg, err := server.GetTssAddress(ctx, &protoReq) return msg, metadata, err diff --git a/x/crosschain/types/tx.pb.go b/x/crosschain/types/tx.pb.go index 3261f28ea9..6b173e9478 100644 --- a/x/crosschain/types/tx.pb.go +++ b/x/crosschain/types/tx.pb.go @@ -31,6 +31,95 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package +type MsgMigrateTssFunds struct { + Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"` + ChainId int64 `protobuf:"varint,2,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + Amount github_com_cosmos_cosmos_sdk_types.Uint `protobuf:"bytes,3,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Uint" json:"amount"` +} + +func (m *MsgMigrateTssFunds) Reset() { *m = MsgMigrateTssFunds{} } +func (m *MsgMigrateTssFunds) String() string { return proto.CompactTextString(m) } +func (*MsgMigrateTssFunds) ProtoMessage() {} +func (*MsgMigrateTssFunds) Descriptor() ([]byte, []int) { + return fileDescriptor_81d6d611190b7635, []int{0} +} +func (m *MsgMigrateTssFunds) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgMigrateTssFunds) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgMigrateTssFunds.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 *MsgMigrateTssFunds) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgMigrateTssFunds.Merge(m, src) +} +func (m *MsgMigrateTssFunds) XXX_Size() int { + return m.Size() +} +func (m *MsgMigrateTssFunds) XXX_DiscardUnknown() { + xxx_messageInfo_MsgMigrateTssFunds.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgMigrateTssFunds proto.InternalMessageInfo + +func (m *MsgMigrateTssFunds) GetCreator() string { + if m != nil { + return m.Creator + } + return "" +} + +func (m *MsgMigrateTssFunds) GetChainId() int64 { + if m != nil { + return m.ChainId + } + return 0 +} + +type MsgMigrateTssFundsResponse struct { +} + +func (m *MsgMigrateTssFundsResponse) Reset() { *m = MsgMigrateTssFundsResponse{} } +func (m *MsgMigrateTssFundsResponse) String() string { return proto.CompactTextString(m) } +func (*MsgMigrateTssFundsResponse) ProtoMessage() {} +func (*MsgMigrateTssFundsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_81d6d611190b7635, []int{1} +} +func (m *MsgMigrateTssFundsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgMigrateTssFundsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgMigrateTssFundsResponse.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 *MsgMigrateTssFundsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgMigrateTssFundsResponse.Merge(m, src) +} +func (m *MsgMigrateTssFundsResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgMigrateTssFundsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgMigrateTssFundsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgMigrateTssFundsResponse proto.InternalMessageInfo + type MsgUpdateTssAddress struct { Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"` TssPubkey string `protobuf:"bytes,2,opt,name=tss_pubkey,json=tssPubkey,proto3" json:"tss_pubkey,omitempty"` @@ -40,7 +129,7 @@ func (m *MsgUpdateTssAddress) Reset() { *m = MsgUpdateTssAddress{} } func (m *MsgUpdateTssAddress) String() string { return proto.CompactTextString(m) } func (*MsgUpdateTssAddress) ProtoMessage() {} func (*MsgUpdateTssAddress) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{0} + return fileDescriptor_81d6d611190b7635, []int{2} } func (m *MsgUpdateTssAddress) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -90,7 +179,7 @@ func (m *MsgUpdateTssAddressResponse) Reset() { *m = MsgUpdateTssAddress func (m *MsgUpdateTssAddressResponse) String() string { return proto.CompactTextString(m) } func (*MsgUpdateTssAddressResponse) ProtoMessage() {} func (*MsgUpdateTssAddressResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{1} + return fileDescriptor_81d6d611190b7635, []int{3} } func (m *MsgUpdateTssAddressResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -133,7 +222,7 @@ func (m *MsgWhitelistERC20) Reset() { *m = MsgWhitelistERC20{} } func (m *MsgWhitelistERC20) String() string { return proto.CompactTextString(m) } func (*MsgWhitelistERC20) ProtoMessage() {} func (*MsgWhitelistERC20) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{2} + return fileDescriptor_81d6d611190b7635, []int{4} } func (m *MsgWhitelistERC20) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -220,7 +309,7 @@ func (m *MsgWhitelistERC20Response) Reset() { *m = MsgWhitelistERC20Resp func (m *MsgWhitelistERC20Response) String() string { return proto.CompactTextString(m) } func (*MsgWhitelistERC20Response) ProtoMessage() {} func (*MsgWhitelistERC20Response) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{3} + return fileDescriptor_81d6d611190b7635, []int{5} } func (m *MsgWhitelistERC20Response) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -277,7 +366,7 @@ func (m *MsgAddToOutTxTracker) Reset() { *m = MsgAddToOutTxTracker{} } func (m *MsgAddToOutTxTracker) String() string { return proto.CompactTextString(m) } func (*MsgAddToOutTxTracker) ProtoMessage() {} func (*MsgAddToOutTxTracker) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{4} + return fileDescriptor_81d6d611190b7635, []int{6} } func (m *MsgAddToOutTxTracker) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -362,7 +451,7 @@ func (m *MsgAddToOutTxTrackerResponse) Reset() { *m = MsgAddToOutTxTrack func (m *MsgAddToOutTxTrackerResponse) String() string { return proto.CompactTextString(m) } func (*MsgAddToOutTxTrackerResponse) ProtoMessage() {} func (*MsgAddToOutTxTrackerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{5} + return fileDescriptor_81d6d611190b7635, []int{7} } func (m *MsgAddToOutTxTrackerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -401,7 +490,7 @@ func (m *MsgRemoveFromOutTxTracker) Reset() { *m = MsgRemoveFromOutTxTra func (m *MsgRemoveFromOutTxTracker) String() string { return proto.CompactTextString(m) } func (*MsgRemoveFromOutTxTracker) ProtoMessage() {} func (*MsgRemoveFromOutTxTracker) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{6} + return fileDescriptor_81d6d611190b7635, []int{8} } func (m *MsgRemoveFromOutTxTracker) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -458,7 +547,7 @@ func (m *MsgRemoveFromOutTxTrackerResponse) Reset() { *m = MsgRemoveFrom func (m *MsgRemoveFromOutTxTrackerResponse) String() string { return proto.CompactTextString(m) } func (*MsgRemoveFromOutTxTrackerResponse) ProtoMessage() {} func (*MsgRemoveFromOutTxTrackerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{7} + return fileDescriptor_81d6d611190b7635, []int{9} } func (m *MsgRemoveFromOutTxTrackerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -498,7 +587,7 @@ func (m *MsgCreateTSSVoter) Reset() { *m = MsgCreateTSSVoter{} } func (m *MsgCreateTSSVoter) String() string { return proto.CompactTextString(m) } func (*MsgCreateTSSVoter) ProtoMessage() {} func (*MsgCreateTSSVoter) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{8} + return fileDescriptor_81d6d611190b7635, []int{10} } func (m *MsgCreateTSSVoter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -562,7 +651,7 @@ func (m *MsgCreateTSSVoterResponse) Reset() { *m = MsgCreateTSSVoterResp func (m *MsgCreateTSSVoterResponse) String() string { return proto.CompactTextString(m) } func (*MsgCreateTSSVoterResponse) ProtoMessage() {} func (*MsgCreateTSSVoterResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{9} + return fileDescriptor_81d6d611190b7635, []int{11} } func (m *MsgCreateTSSVoterResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -603,7 +692,7 @@ func (m *MsgGasPriceVoter) Reset() { *m = MsgGasPriceVoter{} } func (m *MsgGasPriceVoter) String() string { return proto.CompactTextString(m) } func (*MsgGasPriceVoter) ProtoMessage() {} func (*MsgGasPriceVoter) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{10} + return fileDescriptor_81d6d611190b7635, []int{12} } func (m *MsgGasPriceVoter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -674,7 +763,7 @@ func (m *MsgGasPriceVoterResponse) Reset() { *m = MsgGasPriceVoterRespon func (m *MsgGasPriceVoterResponse) String() string { return proto.CompactTextString(m) } func (*MsgGasPriceVoterResponse) ProtoMessage() {} func (*MsgGasPriceVoterResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{11} + return fileDescriptor_81d6d611190b7635, []int{13} } func (m *MsgGasPriceVoterResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -713,7 +802,7 @@ func (m *MsgNonceVoter) Reset() { *m = MsgNonceVoter{} } func (m *MsgNonceVoter) String() string { return proto.CompactTextString(m) } func (*MsgNonceVoter) ProtoMessage() {} func (*MsgNonceVoter) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{12} + return fileDescriptor_81d6d611190b7635, []int{14} } func (m *MsgNonceVoter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -770,7 +859,7 @@ func (m *MsgNonceVoterResponse) Reset() { *m = MsgNonceVoterResponse{} } func (m *MsgNonceVoterResponse) String() string { return proto.CompactTextString(m) } func (*MsgNonceVoterResponse) ProtoMessage() {} func (*MsgNonceVoterResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{13} + return fileDescriptor_81d6d611190b7635, []int{15} } func (m *MsgNonceVoterResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -818,7 +907,7 @@ func (m *MsgVoteOnObservedOutboundTx) Reset() { *m = MsgVoteOnObservedOu func (m *MsgVoteOnObservedOutboundTx) String() string { return proto.CompactTextString(m) } func (*MsgVoteOnObservedOutboundTx) ProtoMessage() {} func (*MsgVoteOnObservedOutboundTx) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{14} + return fileDescriptor_81d6d611190b7635, []int{16} } func (m *MsgVoteOnObservedOutboundTx) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -924,7 +1013,7 @@ func (m *MsgVoteOnObservedOutboundTxResponse) Reset() { *m = MsgVoteOnOb func (m *MsgVoteOnObservedOutboundTxResponse) String() string { return proto.CompactTextString(m) } func (*MsgVoteOnObservedOutboundTxResponse) ProtoMessage() {} func (*MsgVoteOnObservedOutboundTxResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{15} + return fileDescriptor_81d6d611190b7635, []int{17} } func (m *MsgVoteOnObservedOutboundTxResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -975,7 +1064,7 @@ func (m *MsgVoteOnObservedInboundTx) Reset() { *m = MsgVoteOnObservedInb func (m *MsgVoteOnObservedInboundTx) String() string { return proto.CompactTextString(m) } func (*MsgVoteOnObservedInboundTx) ProtoMessage() {} func (*MsgVoteOnObservedInboundTx) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{16} + return fileDescriptor_81d6d611190b7635, []int{18} } func (m *MsgVoteOnObservedInboundTx) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1095,7 +1184,7 @@ func (m *MsgVoteOnObservedInboundTxResponse) Reset() { *m = MsgVoteOnObs func (m *MsgVoteOnObservedInboundTxResponse) String() string { return proto.CompactTextString(m) } func (*MsgVoteOnObservedInboundTxResponse) ProtoMessage() {} func (*MsgVoteOnObservedInboundTxResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{17} + return fileDescriptor_81d6d611190b7635, []int{19} } func (m *MsgVoteOnObservedInboundTxResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1134,7 +1223,7 @@ func (m *MsgSetNodeKeys) Reset() { *m = MsgSetNodeKeys{} } func (m *MsgSetNodeKeys) String() string { return proto.CompactTextString(m) } func (*MsgSetNodeKeys) ProtoMessage() {} func (*MsgSetNodeKeys) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{18} + return fileDescriptor_81d6d611190b7635, []int{20} } func (m *MsgSetNodeKeys) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1191,7 +1280,7 @@ func (m *MsgSetNodeKeysResponse) Reset() { *m = MsgSetNodeKeysResponse{} func (m *MsgSetNodeKeysResponse) String() string { return proto.CompactTextString(m) } func (*MsgSetNodeKeysResponse) ProtoMessage() {} func (*MsgSetNodeKeysResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_81d6d611190b7635, []int{19} + return fileDescriptor_81d6d611190b7635, []int{21} } func (m *MsgSetNodeKeysResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1221,6 +1310,8 @@ func (m *MsgSetNodeKeysResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgSetNodeKeysResponse proto.InternalMessageInfo func init() { + proto.RegisterType((*MsgMigrateTssFunds)(nil), "zetachain.zetacore.crosschain.MsgMigrateTssFunds") + proto.RegisterType((*MsgMigrateTssFundsResponse)(nil), "zetachain.zetacore.crosschain.MsgMigrateTssFundsResponse") proto.RegisterType((*MsgUpdateTssAddress)(nil), "zetachain.zetacore.crosschain.MsgUpdateTssAddress") proto.RegisterType((*MsgUpdateTssAddressResponse)(nil), "zetachain.zetacore.crosschain.MsgUpdateTssAddressResponse") proto.RegisterType((*MsgWhitelistERC20)(nil), "zetachain.zetacore.crosschain.MsgWhitelistERC20") @@ -1246,94 +1337,97 @@ func init() { func init() { proto.RegisterFile("crosschain/tx.proto", fileDescriptor_81d6d611190b7635) } var fileDescriptor_81d6d611190b7635 = []byte{ - // 1383 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0x4f, 0x6f, 0x1b, 0x45, - 0x14, 0xcf, 0x36, 0x89, 0x63, 0xbf, 0xc4, 0x69, 0xb2, 0x49, 0x9b, 0xed, 0xa6, 0x71, 0xda, 0x0d, - 0x2d, 0x15, 0x6a, 0xec, 0xe2, 0x82, 0x28, 0x85, 0x03, 0x4d, 0x54, 0xd2, 0x50, 0x9c, 0x54, 0x1b, - 0x17, 0xa4, 0x5e, 0x56, 0xeb, 0xdd, 0xc9, 0x7a, 0x15, 0xef, 0x8e, 0xb5, 0x33, 0x8e, 0xec, 0x88, - 0x13, 0x12, 0x07, 0x6e, 0x1c, 0x90, 0x40, 0x7c, 0x01, 0xbe, 0x4a, 0xb9, 0x55, 0x9c, 0x28, 0x87, - 0x0a, 0x9a, 0x6f, 0xc0, 0x27, 0x40, 0xf3, 0x67, 0x37, 0x5e, 0x27, 0xb6, 0xe3, 0x20, 0x4e, 0x9e, - 0xf7, 0xe6, 0xfd, 0xde, 0xbf, 0x79, 0x6f, 0xe6, 0xad, 0x61, 0xc1, 0x89, 0x30, 0x21, 0x4e, 0xdd, - 0xf6, 0xc3, 0x12, 0x6d, 0x17, 0x9b, 0x11, 0xa6, 0x58, 0x5d, 0x39, 0x42, 0xd4, 0xe6, 0xbc, 0x22, - 0x5f, 0xe1, 0x08, 0x15, 0x4f, 0xe4, 0xf4, 0x05, 0x07, 0x07, 0x01, 0x0e, 0x4b, 0xe2, 0x47, 0x60, - 0xf4, 0x45, 0x0f, 0x7b, 0x98, 0x2f, 0x4b, 0x6c, 0x25, 0xb8, 0xc6, 0x0e, 0x2c, 0x54, 0x88, 0xf7, - 0xbc, 0xe9, 0xda, 0x14, 0x55, 0x09, 0x79, 0xe4, 0xba, 0x11, 0x22, 0x44, 0xd5, 0x60, 0xca, 0x89, - 0x90, 0x4d, 0x71, 0xa4, 0x29, 0x37, 0x94, 0x3b, 0x39, 0x33, 0x26, 0xd5, 0x15, 0x00, 0x4a, 0x88, - 0xd5, 0x6c, 0xd5, 0x0e, 0x50, 0x47, 0xbb, 0xc4, 0x37, 0x73, 0x94, 0x90, 0x67, 0x9c, 0x61, 0xac, - 0xc0, 0xf2, 0x19, 0xfa, 0x4c, 0x44, 0x9a, 0x38, 0x24, 0xc8, 0xf8, 0x5d, 0x81, 0xf9, 0x0a, 0xf1, - 0xbe, 0xae, 0xfb, 0x14, 0x35, 0x7c, 0x42, 0x1f, 0x9b, 0x9b, 0xe5, 0x7b, 0x03, 0xac, 0xad, 0x41, - 0x1e, 0x45, 0x4e, 0xf9, 0x9e, 0x65, 0x0b, 0x45, 0xd2, 0xe0, 0x0c, 0x67, 0xc6, 0xce, 0x5e, 0x83, - 0x2c, 0x8f, 0xdb, 0xf2, 0x5d, 0x6d, 0xfc, 0x86, 0x72, 0x67, 0xdc, 0x9c, 0xe2, 0xf4, 0xb6, 0xab, - 0xaa, 0x30, 0x11, 0xda, 0x01, 0xd2, 0x26, 0x38, 0x8c, 0xaf, 0xd5, 0xab, 0x90, 0x21, 0x9d, 0xa0, - 0x86, 0x1b, 0xda, 0x24, 0xe7, 0x4a, 0x4a, 0xd5, 0x21, 0xeb, 0x22, 0xc7, 0x0f, 0xec, 0x06, 0xd1, - 0x32, 0x37, 0x94, 0x3b, 0x79, 0x33, 0xa1, 0xd5, 0x65, 0xc8, 0x79, 0x36, 0xb1, 0x1a, 0x7e, 0xe0, - 0x53, 0x6d, 0x8a, 0xdb, 0xc8, 0x7a, 0x36, 0xf9, 0x92, 0xd1, 0x86, 0x05, 0xd7, 0x4e, 0xc5, 0x14, - 0x47, 0xcc, 0x22, 0x38, 0x4a, 0x45, 0x20, 0x22, 0x9c, 0x39, 0xea, 0x8e, 0x60, 0x05, 0xc0, 0x71, - 0x68, 0xdb, 0xf2, 0x43, 0x17, 0xb5, 0xe3, 0xa4, 0x32, 0xce, 0x36, 0x63, 0x18, 0xaf, 0x15, 0x58, - 0xac, 0x10, 0xef, 0x91, 0xeb, 0x56, 0xf1, 0x6e, 0x8b, 0x56, 0xdb, 0xd5, 0xc8, 0x76, 0x0e, 0x50, - 0x34, 0x20, 0x71, 0xdd, 0x39, 0xb9, 0x94, 0xce, 0xc9, 0x22, 0x4c, 0x86, 0x38, 0x74, 0x10, 0xcf, - 0xd5, 0x84, 0x29, 0x08, 0x75, 0x09, 0xa6, 0x68, 0xdb, 0xaa, 0xdb, 0xa4, 0x2e, 0x93, 0x95, 0xa1, - 0xed, 0x27, 0x36, 0xa9, 0xab, 0x6b, 0x30, 0xd9, 0x8c, 0x30, 0xde, 0xe7, 0xd9, 0x9a, 0x2e, 0xe7, - 0x8b, 0xb2, 0xaa, 0x9e, 0x31, 0xa6, 0x29, 0xf6, 0x58, 0x00, 0xb5, 0x06, 0x76, 0x0e, 0x84, 0x82, - 0x8c, 0x08, 0x80, 0x73, 0xb8, 0x8e, 0x6b, 0x90, 0x4d, 0xa2, 0x13, 0xd9, 0x9b, 0x8a, 0x63, 0x2b, - 0xc0, 0xf5, 0xb3, 0x42, 0x4b, 0x2a, 0x66, 0x9f, 0x27, 0xd7, 0x44, 0x01, 0x3e, 0x44, 0x9f, 0x47, - 0x38, 0xf8, 0x9f, 0xe2, 0x37, 0xd6, 0xe0, 0x66, 0x5f, 0x3b, 0x89, 0x33, 0xbf, 0x8a, 0xf2, 0xdd, - 0x64, 0x46, 0x50, 0x75, 0x6f, 0xef, 0x2b, 0x4c, 0x07, 0x7a, 0x31, 0xb8, 0x59, 0xd4, 0xf7, 0x60, - 0xee, 0x00, 0x75, 0xb6, 0x50, 0xf8, 0x02, 0x51, 0xfb, 0x09, 0xf2, 0xbd, 0x3a, 0x95, 0x05, 0x7c, - 0x8a, 0xaf, 0xae, 0x43, 0x86, 0x50, 0x9b, 0xb6, 0x08, 0x3f, 0x9e, 0xd9, 0xf2, 0x95, 0xf8, 0x1c, - 0x4c, 0xe4, 0x20, 0xff, 0x10, 0xed, 0xf1, 0x4d, 0x53, 0x0a, 0x19, 0xcb, 0x3c, 0x6d, 0x69, 0x47, - 0x93, 0x30, 0x7e, 0x56, 0x60, 0xae, 0x42, 0xbc, 0x2d, 0x9b, 0x3c, 0x8b, 0x7c, 0x07, 0x0d, 0x8b, - 0x62, 0x70, 0x2e, 0x9b, 0x4c, 0x45, 0x9c, 0x4b, 0x4e, 0xa8, 0x37, 0x61, 0x46, 0x54, 0x43, 0xd8, - 0x0a, 0x6a, 0x28, 0xe2, 0x1e, 0x4f, 0x98, 0xd3, 0x9c, 0xb7, 0xc3, 0x59, 0xbc, 0x09, 0x5b, 0xcd, - 0x66, 0xa3, 0x93, 0x34, 0x21, 0xa7, 0x0c, 0x1d, 0xb4, 0x5e, 0xcf, 0x12, 0xb7, 0x5f, 0x40, 0xbe, - 0x42, 0xbc, 0x1d, 0x76, 0x5c, 0xff, 0xcd, 0xe5, 0x33, 0x8e, 0x7f, 0x09, 0xae, 0xa4, 0x74, 0x27, - 0x46, 0x5f, 0x4f, 0xf2, 0x1b, 0x8d, 0x31, 0x77, 0xc3, 0xdd, 0x1a, 0x41, 0xd1, 0x21, 0x72, 0x77, - 0x5b, 0xb4, 0x86, 0x5b, 0xa1, 0x5b, 0x6d, 0x0f, 0xf0, 0x61, 0x19, 0x78, 0x0b, 0x8b, 0x96, 0x10, - 0x67, 0x9f, 0x65, 0x0c, 0xde, 0x11, 0x45, 0x58, 0xc0, 0x52, 0x99, 0x85, 0x59, 0xa9, 0x09, 0xb1, - 0x71, 0x2e, 0x36, 0x8f, 0x4f, 0xec, 0x54, 0x85, 0xfc, 0xa7, 0xa0, 0xf7, 0xc8, 0x8b, 0xee, 0x12, - 0x45, 0x23, 0x12, 0xac, 0xa5, 0x60, 0x1b, 0x27, 0xfb, 0xea, 0x87, 0xb0, 0xd4, 0x83, 0x66, 0xb7, - 0x59, 0x8b, 0x20, 0x57, 0x03, 0x0e, 0x5d, 0x4c, 0x41, 0xb7, 0x6c, 0xf2, 0x9c, 0x20, 0x57, 0x3d, - 0x02, 0xa3, 0x07, 0x86, 0xf6, 0xf7, 0x91, 0x43, 0xfd, 0x43, 0xc4, 0x15, 0x88, 0xa3, 0x9f, 0x66, - 0x3e, 0x6f, 0x14, 0x5f, 0xbe, 0x59, 0x1d, 0xfb, 0xf3, 0xcd, 0xea, 0x6d, 0xcf, 0xa7, 0xf5, 0x56, - 0x8d, 0x55, 0x67, 0xc9, 0xc1, 0x24, 0xc0, 0x44, 0xfe, 0xac, 0x13, 0xf7, 0xa0, 0x44, 0x3b, 0x4d, - 0x44, 0x8a, 0xdb, 0x21, 0x35, 0x0b, 0x29, 0x8b, 0x8f, 0x63, 0xbd, 0xf1, 0xc9, 0xab, 0x5f, 0x0c, - 0xb1, 0x2d, 0xae, 0xe2, 0x19, 0xee, 0x7d, 0x7f, 0x5d, 0xfc, 0x82, 0x56, 0x31, 0xcc, 0x1e, 0xda, - 0x8d, 0x16, 0xb2, 0x22, 0xd1, 0x2b, 0xae, 0x28, 0xba, 0x8d, 0x27, 0xd2, 0xe7, 0x77, 0xcf, 0xe1, - 0xf3, 0x73, 0x3f, 0xa4, 0xff, 0xbc, 0x59, 0xbd, 0xd2, 0xb1, 0x83, 0xc6, 0x43, 0x23, 0xad, 0xce, - 0x30, 0xf3, 0x9c, 0x21, 0x5b, 0xd1, 0xed, 0x6a, 0xd6, 0xcc, 0x39, 0x9a, 0x55, 0x5d, 0x85, 0x69, - 0x11, 0x22, 0xaf, 0x51, 0x79, 0x43, 0x02, 0x67, 0x6d, 0x32, 0x8e, 0x7a, 0x1b, 0x2e, 0x0b, 0x01, - 0x76, 0x9b, 0x88, 0xea, 0xcd, 0xf2, 0xc8, 0xf3, 0x9c, 0x5d, 0x25, 0x84, 0x57, 0xae, 0xba, 0x0e, - 0x39, 0x07, 0xfb, 0xa1, 0xc5, 0x5c, 0xd6, 0x72, 0xdc, 0xf4, 0x5c, 0x6c, 0x7a, 0x13, 0xfb, 0x61, - 0xb5, 0xd3, 0x44, 0x66, 0xd6, 0x91, 0x2b, 0xe3, 0x16, 0xac, 0x0d, 0x28, 0xed, 0xa4, 0x05, 0xfe, - 0x1e, 0x07, 0xfd, 0x94, 0xdc, 0x76, 0x38, 0xbc, 0x03, 0x58, 0x93, 0xa3, 0xd0, 0x45, 0x91, 0x2c, - 0x7f, 0x49, 0xb1, 0x70, 0xc4, 0xca, 0xea, 0x79, 0xb7, 0xf3, 0x82, 0xbd, 0x29, 0x5b, 0x55, 0x87, - 0xac, 0x4c, 0x71, 0x24, 0x1f, 0xa5, 0x84, 0x56, 0x6f, 0xc1, 0x6c, 0xbc, 0x96, 0x69, 0x9b, 0x14, - 0x2a, 0x62, 0xae, 0xc8, 0xdc, 0x16, 0x64, 0xec, 0x00, 0xb7, 0x42, 0x2a, 0x1e, 0xa5, 0x8d, 0xd2, - 0x88, 0x47, 0x6e, 0x4a, 0x38, 0x8b, 0x32, 0x40, 0x84, 0xd8, 0x9e, 0x48, 0x7d, 0xce, 0x8c, 0x49, - 0xf5, 0x3a, 0x00, 0x4b, 0xb9, 0xec, 0xe0, 0x9c, 0xf0, 0xd3, 0x0f, 0x65, 0xe3, 0xde, 0x86, 0xcb, - 0x7e, 0x68, 0xc9, 0xc7, 0x51, 0x74, 0xab, 0x68, 0xb9, 0xbc, 0x1f, 0x76, 0xb7, 0x68, 0x6a, 0xc2, - 0x98, 0xe6, 0x12, 0xc9, 0x84, 0x91, 0x3e, 0xd7, 0x99, 0x61, 0xe7, 0xca, 0x74, 0xd1, 0xb6, 0x85, - 0x23, 0xdf, 0xf3, 0x43, 0x2d, 0x2f, 0x1c, 0xa2, 0xed, 0x5d, 0x4e, 0xb3, 0xfb, 0xcf, 0x26, 0x04, - 0x51, 0x6d, 0x96, 0x6f, 0x08, 0xc2, 0x78, 0x07, 0x8c, 0xfe, 0x47, 0x9c, 0x54, 0xc2, 0xf7, 0x0a, - 0xcc, 0x56, 0x88, 0xb7, 0x87, 0xe8, 0x0e, 0x76, 0xd1, 0x53, 0xd4, 0x19, 0x34, 0x29, 0x96, 0x20, - 0x27, 0x1e, 0xbe, 0x3d, 0x44, 0x79, 0x01, 0x4c, 0x97, 0xe7, 0x93, 0xe1, 0xa1, 0x55, 0x7b, 0xca, - 0x37, 0xcc, 0x13, 0x19, 0xf5, 0x2e, 0xa8, 0xac, 0xbe, 0x89, 0xef, 0x85, 0x28, 0xb2, 0xe4, 0x6c, - 0x24, 0xaf, 0xc4, 0x39, 0x4a, 0xc8, 0x1e, 0xdf, 0x90, 0x7c, 0x43, 0x83, 0xab, 0x69, 0x57, 0x62, - 0x2f, 0xcb, 0xbf, 0xe5, 0x60, 0xbc, 0x42, 0x3c, 0xf5, 0x3b, 0x05, 0xe6, 0x4f, 0xcf, 0x4c, 0xf7, - 0x8b, 0x03, 0x87, 0xe7, 0xe2, 0x59, 0xd3, 0x88, 0xfe, 0xc9, 0x05, 0x40, 0xc9, 0x08, 0xf8, 0xa3, - 0x02, 0x57, 0xfb, 0x0c, 0x30, 0x0f, 0x86, 0xeb, 0x3d, 0x1b, 0xa9, 0x7f, 0x76, 0x51, 0x64, 0xe2, - 0xd6, 0x37, 0x30, 0xdb, 0x33, 0xc8, 0xdc, 0x1b, 0xae, 0x33, 0x8d, 0xd0, 0x1f, 0x8c, 0x8a, 0x48, - 0xac, 0x77, 0x20, 0x9f, 0x9e, 0x3f, 0x4a, 0xc3, 0x55, 0xa5, 0x00, 0xfa, 0x47, 0x23, 0x02, 0x12, - 0xd3, 0x4d, 0x80, 0xae, 0x21, 0xe2, 0xee, 0x70, 0x35, 0x27, 0xd2, 0xfa, 0x07, 0xa3, 0x48, 0x27, - 0x16, 0x7f, 0x51, 0x40, 0xeb, 0x3b, 0x41, 0x3c, 0x1c, 0xae, 0xb2, 0x1f, 0x56, 0xdf, 0xb8, 0x38, - 0x36, 0x71, 0xee, 0x27, 0x05, 0x96, 0xfa, 0xdd, 0xed, 0x1f, 0x8f, 0xaa, 0x3f, 0x81, 0xea, 0x8f, - 0x2e, 0x0c, 0xed, 0xae, 0xd0, 0x9e, 0x2f, 0xc5, 0x73, 0x54, 0x68, 0x1a, 0x71, 0x9e, 0x0a, 0xed, - 0xf3, 0xe5, 0xf6, 0xad, 0x02, 0x73, 0xa7, 0x3e, 0x8c, 0xcb, 0xc3, 0xd5, 0xf5, 0x62, 0xf4, 0x87, - 0xa3, 0x63, 0x62, 0x27, 0x36, 0x9e, 0xbe, 0x7c, 0x5b, 0x50, 0x5e, 0xbd, 0x2d, 0x28, 0x7f, 0xbd, - 0x2d, 0x28, 0x3f, 0x1c, 0x17, 0xc6, 0x5e, 0x1d, 0x17, 0xc6, 0xfe, 0x38, 0x2e, 0x8c, 0xbd, 0x78, - 0xbf, 0xeb, 0x05, 0x63, 0x5a, 0xd7, 0xc5, 0x7f, 0x04, 0xb1, 0x81, 0x52, 0xbb, 0xd4, 0xfd, 0xcf, - 0x01, 0x7b, 0xd0, 0x6a, 0x19, 0xfe, 0xcd, 0x7f, 0xff, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x43, - 0xc6, 0x61, 0x3f, 0x54, 0x10, 0x00, 0x00, + // 1440 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0x4f, 0x6f, 0xdb, 0xc6, + 0x12, 0x37, 0x9f, 0x6d, 0x59, 0x1a, 0x5b, 0x8e, 0xbd, 0x76, 0x62, 0x86, 0x8e, 0xe5, 0x84, 0x7e, + 0xc9, 0x0b, 0x1e, 0x62, 0x29, 0x51, 0xde, 0x43, 0x93, 0xb4, 0x87, 0xc6, 0x46, 0xe2, 0xb8, 0xa9, + 0xec, 0x80, 0x56, 0x5a, 0x20, 0x17, 0x82, 0x22, 0xd7, 0x14, 0x61, 0x91, 0x2b, 0x70, 0x57, 0x86, + 0x64, 0x14, 0x28, 0x50, 0xa0, 0x87, 0xde, 0x8a, 0xa2, 0x40, 0x8b, 0x7e, 0x81, 0x7e, 0x95, 0xa0, + 0xa7, 0xa0, 0xa7, 0xa6, 0x87, 0xa0, 0x4d, 0xbe, 0x41, 0x3f, 0x41, 0xb1, 0xbb, 0x24, 0x2d, 0xca, + 0x96, 0x64, 0x39, 0xe8, 0x49, 0x3b, 0xb3, 0xf3, 0x9b, 0x7f, 0x3b, 0xb3, 0x3b, 0x22, 0x2c, 0xd8, + 0x21, 0xa1, 0xd4, 0xae, 0x5b, 0x5e, 0x50, 0x62, 0xed, 0x62, 0x33, 0x24, 0x8c, 0xa0, 0x95, 0x23, + 0xcc, 0x2c, 0xc1, 0x2b, 0x8a, 0x15, 0x09, 0x71, 0xf1, 0x58, 0x4e, 0x5b, 0xb0, 0x89, 0xef, 0x93, + 0xa0, 0x24, 0x7f, 0x24, 0x46, 0x5b, 0x74, 0x89, 0x4b, 0xc4, 0xb2, 0xc4, 0x57, 0x92, 0xab, 0x7f, + 0xa7, 0x00, 0xaa, 0x50, 0xb7, 0xe2, 0xb9, 0xa1, 0xc5, 0x70, 0x95, 0xd2, 0xc7, 0xad, 0xc0, 0xa1, + 0x48, 0x85, 0x29, 0x3b, 0xc4, 0x16, 0x23, 0xa1, 0xaa, 0x5c, 0x55, 0x6e, 0xe6, 0x8c, 0x98, 0x44, + 0x97, 0x21, 0x2b, 0x8c, 0x98, 0x9e, 0xa3, 0xfe, 0xeb, 0xaa, 0x72, 0x73, 0xdc, 0x98, 0x12, 0xf4, + 0xb6, 0x83, 0xb6, 0x20, 0x63, 0xf9, 0xa4, 0x15, 0x30, 0x75, 0x9c, 0x63, 0x36, 0x4a, 0x2f, 0xdf, + 0xac, 0x8e, 0xfd, 0xfe, 0x66, 0xf5, 0x3f, 0xae, 0xc7, 0xea, 0xad, 0x5a, 0xd1, 0x26, 0x7e, 0xc9, + 0x26, 0xd4, 0x27, 0x34, 0xfa, 0x59, 0xa7, 0xce, 0x41, 0x89, 0x75, 0x9a, 0x98, 0x16, 0x9f, 0x7b, + 0x01, 0x33, 0x22, 0xb8, 0x7e, 0x05, 0xb4, 0x93, 0x3e, 0x19, 0x98, 0x36, 0x49, 0x40, 0xb1, 0xbe, + 0x03, 0x0b, 0x15, 0xea, 0x3e, 0x6f, 0x3a, 0x72, 0xf3, 0xa1, 0xe3, 0x84, 0x98, 0x0e, 0x72, 0x79, + 0x05, 0x80, 0x51, 0x6a, 0x36, 0x5b, 0xb5, 0x03, 0xdc, 0x11, 0x4e, 0xe7, 0x8c, 0x1c, 0xa3, 0xf4, + 0x99, 0x60, 0xe8, 0x2b, 0xb0, 0x7c, 0x8a, 0xbe, 0xc4, 0xdc, 0xaf, 0x0a, 0xcc, 0x57, 0xa8, 0xfb, + 0x79, 0xdd, 0x63, 0xb8, 0xe1, 0x51, 0xf6, 0xc8, 0xd8, 0x2c, 0xdf, 0x1e, 0x60, 0x6d, 0x0d, 0xf2, + 0x38, 0xb4, 0xcb, 0xb7, 0x4d, 0x4b, 0x2a, 0x8a, 0x0c, 0xce, 0x08, 0x66, 0xec, 0x6c, 0x77, 0x16, + 0xc7, 0xd3, 0x59, 0x44, 0x30, 0x11, 0x58, 0x3e, 0x56, 0x27, 0x04, 0x4c, 0xac, 0xd1, 0x25, 0xc8, + 0xd0, 0x8e, 0x5f, 0x23, 0x0d, 0x75, 0x52, 0x70, 0x23, 0x0a, 0x69, 0x90, 0x75, 0xb0, 0xed, 0xf9, + 0x56, 0x83, 0xaa, 0x99, 0xab, 0xca, 0xcd, 0xbc, 0x91, 0xd0, 0x68, 0x19, 0x72, 0xae, 0x45, 0xcd, + 0x86, 0xe7, 0x7b, 0x4c, 0x9d, 0x12, 0x36, 0xb2, 0xae, 0x45, 0x3f, 0xe5, 0xb4, 0x6e, 0xc2, 0xe5, + 0x13, 0x31, 0xc5, 0x11, 0xf3, 0x08, 0x8e, 0x52, 0x11, 0xc8, 0x08, 0x67, 0x8e, 0xba, 0x23, 0x58, + 0x01, 0xb0, 0x6d, 0xd6, 0x36, 0xbd, 0xc0, 0xc1, 0xed, 0x38, 0xa9, 0x9c, 0xb3, 0xcd, 0x19, 0xfa, + 0x6b, 0x05, 0x16, 0x2b, 0xd4, 0x7d, 0xe8, 0x38, 0x55, 0xb2, 0xdb, 0x62, 0xd5, 0x76, 0x35, 0xb4, + 0xec, 0x03, 0x1c, 0x9e, 0xaf, 0xb2, 0x16, 0x61, 0x32, 0x20, 0x81, 0x8d, 0x45, 0xae, 0x26, 0x0c, + 0x49, 0xa0, 0x25, 0x98, 0x62, 0x6d, 0xb3, 0x6e, 0xd1, 0x7a, 0x94, 0xac, 0x0c, 0x6b, 0x3f, 0xb1, + 0x68, 0x1d, 0xad, 0xc1, 0x64, 0x33, 0x24, 0x64, 0x5f, 0x64, 0x6b, 0xba, 0x9c, 0x2f, 0x46, 0x8d, + 0xf0, 0x8c, 0x33, 0x0d, 0xb9, 0xc7, 0x03, 0xa8, 0x35, 0x88, 0x7d, 0x20, 0x15, 0x64, 0x64, 0x00, + 0x82, 0x23, 0x74, 0x5c, 0x86, 0x6c, 0x12, 0x9d, 0xcc, 0xde, 0x54, 0x1c, 0x5b, 0x01, 0xae, 0x9c, + 0x16, 0x5a, 0x52, 0x31, 0xfb, 0x22, 0xb9, 0x06, 0xf6, 0xc9, 0x21, 0x7e, 0x1c, 0x12, 0xff, 0x1f, + 0x8a, 0x5f, 0x5f, 0x83, 0x6b, 0x7d, 0xed, 0x24, 0xce, 0xfc, 0x2c, 0xcb, 0x77, 0x93, 0x1b, 0xc1, + 0xd5, 0xbd, 0xbd, 0xcf, 0x08, 0x1b, 0xe8, 0xc5, 0xe0, 0x66, 0x41, 0xff, 0x85, 0xb9, 0x03, 0xdc, + 0xd9, 0xc2, 0xc1, 0x0b, 0xcc, 0xac, 0x27, 0xd8, 0x73, 0xeb, 0x2c, 0x2a, 0xe0, 0x13, 0x7c, 0xb4, + 0x0e, 0x19, 0xca, 0x2c, 0xd6, 0xa2, 0xe2, 0x78, 0x66, 0xcb, 0x17, 0xe3, 0x73, 0x30, 0xb0, 0x8d, + 0xbd, 0x43, 0xbc, 0x27, 0x36, 0x8d, 0x48, 0x48, 0x5f, 0x16, 0x69, 0x4b, 0x3b, 0x9a, 0x84, 0xf1, + 0xa3, 0x02, 0x73, 0x15, 0xea, 0x6e, 0x59, 0xf4, 0x59, 0xe8, 0xd9, 0x78, 0x58, 0x14, 0x83, 0x73, + 0xd9, 0xe4, 0x2a, 0xe2, 0x5c, 0x0a, 0x02, 0x5d, 0x83, 0x19, 0x59, 0x0d, 0x41, 0xcb, 0xaf, 0xe1, + 0x50, 0x78, 0x3c, 0x61, 0x4c, 0x0b, 0xde, 0x8e, 0x60, 0x89, 0x26, 0x6c, 0x35, 0x9b, 0x8d, 0x4e, + 0xd2, 0x84, 0x82, 0xd2, 0x35, 0x50, 0x7b, 0x3d, 0x4b, 0xdc, 0x7e, 0x01, 0xf9, 0x0a, 0x75, 0x77, + 0xf8, 0x71, 0xbd, 0x9f, 0xcb, 0xa7, 0x1c, 0xff, 0x12, 0x5c, 0x4c, 0xe9, 0x4e, 0x8c, 0xbe, 0x9e, + 0x14, 0x37, 0x1a, 0x67, 0xee, 0x06, 0xbb, 0x35, 0x8a, 0xc3, 0x43, 0xec, 0xec, 0xb6, 0x58, 0x8d, + 0xb4, 0x02, 0xa7, 0xda, 0x1e, 0xe0, 0xc3, 0x32, 0x88, 0x16, 0x96, 0x2d, 0x21, 0xcf, 0x3e, 0xcb, + 0x19, 0xa2, 0x23, 0x8a, 0xb0, 0x40, 0x22, 0x65, 0x26, 0xe1, 0xa5, 0x26, 0xc5, 0xc4, 0x5d, 0x6f, + 0xcc, 0x93, 0x63, 0x3b, 0x55, 0x29, 0xff, 0x11, 0x68, 0x3d, 0xf2, 0xb2, 0xbb, 0x64, 0xd1, 0xc8, + 0x04, 0xab, 0x29, 0xd8, 0xc6, 0xf1, 0x3e, 0xfa, 0x3f, 0x2c, 0xf5, 0xa0, 0xf9, 0x6d, 0xd6, 0xa2, + 0xd8, 0x51, 0x41, 0x40, 0x17, 0x53, 0xd0, 0x2d, 0x8b, 0x3e, 0xa7, 0xd8, 0x41, 0x47, 0xa0, 0xf7, + 0xc0, 0xf0, 0xfe, 0x3e, 0xb6, 0x99, 0x77, 0x88, 0x85, 0x02, 0x79, 0xf4, 0xd3, 0xe2, 0x7d, 0x2a, + 0x46, 0xef, 0xd3, 0x8d, 0x33, 0xbc, 0x4f, 0xdb, 0x01, 0x33, 0x0a, 0x29, 0x8b, 0x8f, 0x62, 0xbd, + 0xf1, 0xc9, 0xa3, 0x4f, 0x86, 0xd8, 0x96, 0x57, 0xf1, 0x8c, 0xf0, 0xbe, 0xbf, 0x2e, 0x71, 0x41, + 0x23, 0x02, 0xb3, 0x87, 0x56, 0xa3, 0x85, 0xcd, 0x50, 0xf6, 0x8a, 0x23, 0x8b, 0x6e, 0xe3, 0xc9, + 0x88, 0x6f, 0xea, 0x5f, 0x6f, 0x56, 0x2f, 0x76, 0x2c, 0xbf, 0xf1, 0x40, 0x4f, 0xab, 0xd3, 0x8d, + 0xbc, 0x60, 0x44, 0xad, 0xe8, 0x74, 0x35, 0x6b, 0xe6, 0x0c, 0xcd, 0x8a, 0x56, 0x61, 0x5a, 0x86, + 0x28, 0x6a, 0x34, 0xba, 0x21, 0x41, 0xb0, 0x36, 0x39, 0x07, 0xdd, 0x80, 0x0b, 0x52, 0x80, 0xdf, + 0x26, 0xb2, 0x7a, 0xb3, 0x22, 0xf2, 0xbc, 0x60, 0x57, 0x29, 0x15, 0x95, 0x8b, 0xd6, 0x21, 0x67, + 0x13, 0x2f, 0x30, 0xb9, 0xcb, 0x6a, 0x4e, 0x98, 0x9e, 0x8b, 0x4d, 0x6f, 0x12, 0x2f, 0xa8, 0x76, + 0x9a, 0xd8, 0xc8, 0xda, 0xd1, 0x4a, 0xbf, 0x0e, 0x6b, 0x03, 0x4a, 0x3b, 0x69, 0x81, 0x3f, 0xc7, + 0xc5, 0x08, 0x91, 0x96, 0xdb, 0x0e, 0x86, 0x77, 0x00, 0x6f, 0x72, 0x1c, 0x38, 0x38, 0x8c, 0xca, + 0x3f, 0xa2, 0x78, 0x38, 0x72, 0x65, 0xf6, 0xbc, 0xdb, 0x79, 0xc9, 0xde, 0x8c, 0x5a, 0x55, 0x83, + 0x6c, 0x94, 0xe2, 0x30, 0x7a, 0x94, 0x12, 0x1a, 0x5d, 0x87, 0xd9, 0x78, 0x1d, 0xa5, 0x6d, 0x52, + 0xaa, 0x88, 0xb9, 0x32, 0x73, 0xc7, 0x63, 0x54, 0xe6, 0xbd, 0xc6, 0x28, 0x1e, 0xa5, 0x8f, 0x29, + 0xb5, 0x5c, 0x99, 0xfa, 0x9c, 0x11, 0x93, 0xe8, 0x0a, 0x00, 0x4f, 0x79, 0xd4, 0xc1, 0x39, 0xe9, + 0xa7, 0x17, 0x44, 0x8d, 0x7b, 0x03, 0x2e, 0x78, 0x81, 0x19, 0x3d, 0x8e, 0xb2, 0x5b, 0x65, 0xcb, + 0xe5, 0xbd, 0xa0, 0xbb, 0x45, 0x53, 0x13, 0xc6, 0xb4, 0x90, 0x48, 0x26, 0x8c, 0xf4, 0xb9, 0xce, + 0x0c, 0x3b, 0x57, 0xae, 0x8b, 0xb5, 0x4d, 0x12, 0x7a, 0xae, 0x17, 0xa8, 0x79, 0xe9, 0x10, 0x6b, + 0xef, 0x0a, 0x9a, 0xdf, 0x7f, 0x16, 0xa5, 0x98, 0xa9, 0xb3, 0x62, 0x43, 0x12, 0xfa, 0xbf, 0x41, + 0xef, 0x7f, 0xc4, 0x49, 0x25, 0x7c, 0xa3, 0xc0, 0x6c, 0x85, 0xba, 0x7b, 0x98, 0xed, 0x10, 0x07, + 0x3f, 0xc5, 0x9d, 0x41, 0x93, 0x62, 0x09, 0x72, 0xf2, 0xe1, 0xdb, 0xc3, 0x4c, 0x14, 0xc0, 0x74, + 0x79, 0x3e, 0x19, 0x1e, 0x5a, 0xb5, 0xa7, 0x62, 0xc3, 0x38, 0x96, 0x41, 0xb7, 0x00, 0xf1, 0xfa, + 0xa6, 0x9e, 0x1b, 0xe0, 0xd0, 0x8c, 0x66, 0xa3, 0xe8, 0x4a, 0x9c, 0x63, 0x94, 0xee, 0x89, 0x8d, + 0x88, 0xaf, 0xab, 0x70, 0x29, 0xed, 0x4a, 0xec, 0x65, 0xf9, 0x17, 0x80, 0xf1, 0x0a, 0x75, 0xd1, + 0xd7, 0x0a, 0xcc, 0x9f, 0x9c, 0x99, 0xee, 0x16, 0x07, 0xce, 0xfb, 0xc5, 0xd3, 0xa6, 0x11, 0xed, + 0xc3, 0x73, 0x80, 0x92, 0x11, 0xf0, 0x7b, 0x05, 0x2e, 0xf5, 0x19, 0x60, 0xee, 0x0d, 0xd7, 0x7b, + 0x3a, 0x52, 0xfb, 0xf8, 0xbc, 0xc8, 0xc4, 0xad, 0x2f, 0x60, 0xb6, 0x67, 0x90, 0xb9, 0x3d, 0x5c, + 0x67, 0x1a, 0xa1, 0xdd, 0x1b, 0x15, 0x91, 0x58, 0xef, 0x40, 0x3e, 0x3d, 0x7f, 0x94, 0x86, 0xab, + 0x4a, 0x01, 0xb4, 0x0f, 0x46, 0x04, 0x24, 0xa6, 0x9b, 0x00, 0x5d, 0x43, 0xc4, 0xad, 0xe1, 0x6a, + 0x8e, 0xa5, 0xb5, 0xff, 0x8d, 0x22, 0x9d, 0x58, 0xfc, 0x49, 0x01, 0xb5, 0xef, 0x04, 0xf1, 0x60, + 0xb8, 0xca, 0x7e, 0x58, 0x6d, 0xe3, 0xfc, 0xd8, 0xc4, 0xb9, 0x1f, 0x14, 0x58, 0xea, 0x77, 0xb7, + 0xdf, 0x1f, 0x55, 0x7f, 0x02, 0xd5, 0x1e, 0x9e, 0x1b, 0xda, 0x5d, 0xa1, 0x3d, 0xff, 0x14, 0xcf, + 0x50, 0xa1, 0x69, 0xc4, 0x59, 0x2a, 0xb4, 0xcf, 0x3f, 0xb7, 0xaf, 0x14, 0x98, 0x3b, 0xf1, 0xc7, + 0xb8, 0x3c, 0x5c, 0x5d, 0x2f, 0x46, 0x7b, 0x30, 0x3a, 0x26, 0x71, 0xe2, 0x4b, 0xb8, 0xd0, 0xfb, + 0x39, 0xe1, 0xce, 0x70, 0x75, 0x3d, 0x10, 0xed, 0xfe, 0xc8, 0x90, 0xd8, 0x81, 0x8d, 0xa7, 0x2f, + 0xdf, 0x16, 0x94, 0x57, 0x6f, 0x0b, 0xca, 0x1f, 0x6f, 0x0b, 0xca, 0xb7, 0xef, 0x0a, 0x63, 0xaf, + 0xde, 0x15, 0xc6, 0x7e, 0x7b, 0x57, 0x18, 0x7b, 0x71, 0xa7, 0xeb, 0x09, 0xe5, 0x4a, 0xd7, 0xe5, + 0x77, 0x95, 0x58, 0x7f, 0xa9, 0x5d, 0xea, 0xfe, 0xda, 0xc2, 0x5f, 0xd4, 0x5a, 0x46, 0x7c, 0x27, + 0xb9, 0xfb, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x59, 0x22, 0xcb, 0x23, 0x88, 0x11, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1357,6 +1451,7 @@ type MsgClient interface { VoteOnObservedInboundTx(ctx context.Context, in *MsgVoteOnObservedInboundTx, opts ...grpc.CallOption) (*MsgVoteOnObservedInboundTxResponse, error) WhitelistERC20(ctx context.Context, in *MsgWhitelistERC20, opts ...grpc.CallOption) (*MsgWhitelistERC20Response, error) UpdateTssAddress(ctx context.Context, in *MsgUpdateTssAddress, opts ...grpc.CallOption) (*MsgUpdateTssAddressResponse, error) + MigrateTssFunds(ctx context.Context, in *MsgMigrateTssFunds, opts ...grpc.CallOption) (*MsgMigrateTssFundsResponse, error) } type msgClient struct { @@ -1448,6 +1543,15 @@ func (c *msgClient) UpdateTssAddress(ctx context.Context, in *MsgUpdateTssAddres return out, nil } +func (c *msgClient) MigrateTssFunds(ctx context.Context, in *MsgMigrateTssFunds, opts ...grpc.CallOption) (*MsgMigrateTssFundsResponse, error) { + out := new(MsgMigrateTssFundsResponse) + err := c.cc.Invoke(ctx, "/zetachain.zetacore.crosschain.Msg/MigrateTssFunds", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. type MsgServer interface { AddToOutTxTracker(context.Context, *MsgAddToOutTxTracker) (*MsgAddToOutTxTrackerResponse, error) @@ -1459,6 +1563,7 @@ type MsgServer interface { VoteOnObservedInboundTx(context.Context, *MsgVoteOnObservedInboundTx) (*MsgVoteOnObservedInboundTxResponse, error) WhitelistERC20(context.Context, *MsgWhitelistERC20) (*MsgWhitelistERC20Response, error) UpdateTssAddress(context.Context, *MsgUpdateTssAddress) (*MsgUpdateTssAddressResponse, error) + MigrateTssFunds(context.Context, *MsgMigrateTssFunds) (*MsgMigrateTssFundsResponse, error) } // UnimplementedMsgServer can be embedded to have forward compatible implementations. @@ -1492,6 +1597,9 @@ func (*UnimplementedMsgServer) WhitelistERC20(ctx context.Context, req *MsgWhite func (*UnimplementedMsgServer) UpdateTssAddress(ctx context.Context, req *MsgUpdateTssAddress) (*MsgUpdateTssAddressResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method UpdateTssAddress not implemented") } +func (*UnimplementedMsgServer) MigrateTssFunds(ctx context.Context, req *MsgMigrateTssFunds) (*MsgMigrateTssFundsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method MigrateTssFunds not implemented") +} func RegisterMsgServer(s grpc1.Server, srv MsgServer) { s.RegisterService(&_Msg_serviceDesc, srv) @@ -1659,6 +1767,24 @@ func _Msg_UpdateTssAddress_Handler(srv interface{}, ctx context.Context, dec fun return interceptor(ctx, in, info, handler) } +func _Msg_MigrateTssFunds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgMigrateTssFunds) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).MigrateTssFunds(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zetachain.zetacore.crosschain.Msg/MigrateTssFunds", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).MigrateTssFunds(ctx, req.(*MsgMigrateTssFunds)) + } + return interceptor(ctx, in, info, handler) +} + var _Msg_serviceDesc = grpc.ServiceDesc{ ServiceName: "zetachain.zetacore.crosschain.Msg", HandlerType: (*MsgServer)(nil), @@ -1699,11 +1825,83 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ MethodName: "UpdateTssAddress", Handler: _Msg_UpdateTssAddress_Handler, }, + { + MethodName: "MigrateTssFunds", + Handler: _Msg_MigrateTssFunds_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "crosschain/tx.proto", } +func (m *MsgMigrateTssFunds) 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 *MsgMigrateTssFunds) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgMigrateTssFunds) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.Amount.Size() + i -= size + if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if m.ChainId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.ChainId)) + i-- + dAtA[i] = 0x10 + } + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintTx(dAtA, i, uint64(len(m.Creator))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgMigrateTssFundsResponse) 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 *MsgMigrateTssFundsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgMigrateTssFundsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + func (m *MsgUpdateTssAddress) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -2567,6 +2765,33 @@ func encodeVarintTx(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } +func (m *MsgMigrateTssFunds) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Creator) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.ChainId != 0 { + n += 1 + sovTx(uint64(m.ChainId)) + } + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgMigrateTssFundsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + func (m *MsgUpdateTssAddress) Size() (n int) { if m == nil { return 0 @@ -2964,6 +3189,191 @@ func sovTx(x uint64) (n int) { func sozTx(x uint64) (n int) { return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } +func (m *MsgMigrateTssFunds) 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: MsgMigrateTssFunds: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgMigrateTssFunds: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + m.ChainId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ChainId |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + 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 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 + } + if err := m.Amount.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 *MsgMigrateTssFundsResponse) 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: MsgMigrateTssFundsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgMigrateTssFundsResponse: 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 *MsgUpdateTssAddress) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/x/emissions/client/cli/query.go b/x/emissions/client/cli/query.go index b4ae1a4e03..bd2ed2b0bb 100644 --- a/x/emissions/client/cli/query.go +++ b/x/emissions/client/cli/query.go @@ -5,12 +5,11 @@ import ( // "strings" "github.com/spf13/cobra" + "github.com/zeta-chain/zetacore/x/emissions/types" "github.com/cosmos/cosmos-sdk/client" // "github.com/cosmos/cosmos-sdk/client/flags" // sdk "github.com/cosmos/cosmos-sdk/types" - - "github.com/zeta-chain/zetacore/x/emissions/types" ) // GetQueryCmd returns the cli query commands for this module diff --git a/x/emissions/client/cli/tx.go b/x/emissions/client/cli/tx.go index 53f12c7cc0..8e1fe8632e 100644 --- a/x/emissions/client/cli/tx.go +++ b/x/emissions/client/cli/tx.go @@ -4,10 +4,9 @@ import ( "fmt" "github.com/spf13/cobra" + "github.com/zeta-chain/zetacore/x/emissions/types" "github.com/cosmos/cosmos-sdk/client" - // "github.com/cosmos/cosmos-sdk/client/flags" - "github.com/zeta-chain/zetacore/x/emissions/types" ) // GetTxCmd returns the transaction commands for this module diff --git a/x/emissions/client/tests/observer_rewards_test.go b/x/emissions/client/tests/observer_rewards_test.go index c3113deb87..853e3a3ad8 100644 --- a/x/emissions/client/tests/observer_rewards_test.go +++ b/x/emissions/client/tests/observer_rewards_test.go @@ -9,19 +9,19 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/bank/client/cli" "github.com/zeta-chain/zetacore/cmd/zetacored/config" - emmisonscli "github.com/zeta-chain/zetacore/x/emissions/client/cli" - emmisonstypes "github.com/zeta-chain/zetacore/x/emissions/types" - observerCli "github.com/zeta-chain/zetacore/x/observer/client/cli" - observerTypes "github.com/zeta-chain/zetacore/x/observer/types" + emissionscli "github.com/zeta-chain/zetacore/x/emissions/client/cli" + emissionstypes "github.com/zeta-chain/zetacore/x/emissions/types" + observercli "github.com/zeta-chain/zetacore/x/observer/client/cli" + observertypes "github.com/zeta-chain/zetacore/x/observer/types" ) func (s *CliTestSuite) TestObserverRewards() { emissionPool := "800000000000000000000azeta" val := s.network.Validators[0] - out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, emmisonscli.CmdListPoolAddresses(), []string{"--output", "json"}) + out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, emissionscli.CmdListPoolAddresses(), []string{"--output", "json"}) s.Require().NoError(err) - resPools := emmisonstypes.QueryListPoolAddressesResponse{} + resPools := emissionstypes.QueryListPoolAddressesResponse{} s.Require().NoError(err) s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &resPools)) txArgs := []string{ @@ -38,22 +38,22 @@ func (s *CliTestSuite) TestObserverRewards() { s.Require().NoError(s.network.WaitForNextBlock()) // Collect parameter values and build assertion map for the randomised ballot set created - emissionFactors := emmisonstypes.QueryGetEmissionsFactorsResponse{} - out, err = clitestutil.ExecTestCLICmd(val.ClientCtx, emmisonscli.CmdGetEmmisonsFactors(), []string{"--output", "json"}) + emissionFactors := emissionstypes.QueryGetEmissionsFactorsResponse{} + out, err = clitestutil.ExecTestCLICmd(val.ClientCtx, emissionscli.CmdGetEmmisonsFactors(), []string{"--output", "json"}) s.Require().NoError(err) s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &emissionFactors)) - emissionParams := emmisonstypes.QueryParamsResponse{} - out, err = clitestutil.ExecTestCLICmd(val.ClientCtx, emmisonscli.CmdQueryParams(), []string{"--output", "json"}) + emissionParams := emissionstypes.QueryParamsResponse{} + out, err = clitestutil.ExecTestCLICmd(val.ClientCtx, emissionscli.CmdQueryParams(), []string{"--output", "json"}) s.Require().NoError(err) s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &emissionParams)) - observerParams := observerTypes.QueryParamsResponse{} - out, err = clitestutil.ExecTestCLICmd(val.ClientCtx, observerCli.CmdQueryParams(), []string{"--output", "json"}) + observerParams := observertypes.QueryParamsResponse{} + out, err = clitestutil.ExecTestCLICmd(val.ClientCtx, observercli.CmdQueryParams(), []string{"--output", "json"}) s.Require().NoError(err) s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &observerParams)) _, err = s.network.WaitForHeight(s.ballots[0].BallotCreationHeight + observerParams.Params.BallotMaturityBlocks) s.Require().NoError(err) - out, err = clitestutil.ExecTestCLICmd(val.ClientCtx, emmisonscli.CmdGetEmmisonsFactors(), []string{"--output", "json"}) - resFactorsNewBlocks := emmisonstypes.QueryGetEmissionsFactorsResponse{} + out, err = clitestutil.ExecTestCLICmd(val.ClientCtx, emissionscli.CmdGetEmmisonsFactors(), []string{"--output", "json"}) + resFactorsNewBlocks := emissionstypes.QueryGetEmissionsFactorsResponse{} s.Require().NoError(err) s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &resFactorsNewBlocks)) // Duration factor is calculated in the same block,so we need to query based from the committed state at which the distribution is done @@ -62,9 +62,9 @@ func (s *CliTestSuite) TestObserverRewards() { asertValues := CalculateObserverRewards(s.ballots, emissionParams.Params.ObserverEmissionPercentage, emissionFactors.ReservesFactor, emissionFactors.BondFactor, emissionFactors.DurationFactor) // Assert withdrawable rewards for each validator - resAvailable := emmisonstypes.QueryShowAvailableEmissionsResponse{} + resAvailable := emissionstypes.QueryShowAvailableEmissionsResponse{} for i := 0; i < len(s.network.Validators); i++ { - out, err = clitestutil.ExecTestCLICmd(val.ClientCtx, emmisonscli.CmdShowAvailableEmissions(), []string{s.network.Validators[i].Address.String(), "--output", "json"}) + out, err = clitestutil.ExecTestCLICmd(val.ClientCtx, emissionscli.CmdShowAvailableEmissions(), []string{s.network.Validators[i].Address.String(), "--output", "json"}) s.Require().NoError(err) s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &resAvailable)) s.Require().Equal(sdk.NewCoin(config.BaseDenom, asertValues[s.network.Validators[i].Address.String()]).String(), resAvailable.Amount, "Validator %s has incorrect withdrawable rewards", s.network.Validators[i].Address.String()) @@ -72,7 +72,7 @@ func (s *CliTestSuite) TestObserverRewards() { } -func CalculateObserverRewards(ballots []*observerTypes.Ballot, observerEmissionPercentage, reservesFactor, bondFactor, durationFactor string) map[string]sdkmath.Int { +func CalculateObserverRewards(ballots []*observertypes.Ballot, observerEmissionPercentage, reservesFactor, bondFactor, durationFactor string) map[string]sdkmath.Int { calculatedDistributer := map[string]sdkmath.Int{} blockRewards := sdk.MustNewDecFromStr(reservesFactor).Mul(sdk.MustNewDecFromStr(bondFactor)).Mul(sdk.MustNewDecFromStr(durationFactor)) observerRewards := sdk.MustNewDecFromStr(observerEmissionPercentage).Mul(blockRewards).TruncateInt() diff --git a/x/emissions/keeper/grpc_query_show_available_emissions.go b/x/emissions/keeper/grpc_query_show_available_emissions.go index c56a6f4d45..4f33bf5f07 100644 --- a/x/emissions/keeper/grpc_query_show_available_emissions.go +++ b/x/emissions/keeper/grpc_query_show_available_emissions.go @@ -4,9 +4,9 @@ import ( "context" "github.com/zeta-chain/zetacore/cmd/zetacored/config" + "github.com/zeta-chain/zetacore/x/emissions/types" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/zeta-chain/zetacore/x/emissions/types" ) func (k Keeper) ShowAvailableEmissions(goCtx context.Context, req *types.QueryShowAvailableEmissionsRequest) (*types.QueryShowAvailableEmissionsResponse, error) { diff --git a/x/emissions/keeper/keeper.go b/x/emissions/keeper/keeper.go index 96d825de3b..3655c42016 100644 --- a/x/emissions/keeper/keeper.go +++ b/x/emissions/keeper/keeper.go @@ -5,11 +5,11 @@ import ( storetypes "github.com/cosmos/cosmos-sdk/store/types" "github.com/tendermint/tendermint/libs/log" + "github.com/zeta-chain/zetacore/x/emissions/types" "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" - "github.com/zeta-chain/zetacore/x/emissions/types" ) type ( diff --git a/x/emissions/module.go b/x/emissions/module.go index 02c7e9437d..a40c9743e9 100644 --- a/x/emissions/module.go +++ b/x/emissions/module.go @@ -8,6 +8,9 @@ import ( "github.com/gorilla/mux" "github.com/grpc-ecosystem/grpc-gateway/runtime" "github.com/spf13/cobra" + "github.com/zeta-chain/zetacore/x/emissions/client/cli" + emissionskeeper "github.com/zeta-chain/zetacore/x/emissions/keeper" + "github.com/zeta-chain/zetacore/x/emissions/types" abci "github.com/tendermint/tendermint/abci/types" @@ -16,9 +19,6 @@ import ( cdctypes "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" - "github.com/zeta-chain/zetacore/x/emissions/client/cli" - "github.com/zeta-chain/zetacore/x/emissions/keeper" - "github.com/zeta-chain/zetacore/x/emissions/types" ) var ( @@ -101,13 +101,13 @@ func (AppModuleBasic) GetQueryCmd() *cobra.Command { type AppModule struct { AppModuleBasic - keeper keeper.Keeper + keeper emissionskeeper.Keeper accountKeeper types.AccountKeeper } func NewAppModule( cdc codec.Codec, - keeper keeper.Keeper, + keeper emissionskeeper.Keeper, accountKeeper types.AccountKeeper, ) AppModule { return AppModule{ @@ -138,7 +138,7 @@ func (am AppModule) LegacyQuerierHandler(_ *codec.LegacyAmino) sdk.Querier { // RegisterServices registers a GRPC query service to respond to the // module-specific GRPC queries. func (am AppModule) RegisterServices(cfg module.Configurator) { - types.RegisterMsgServer(cfg.MsgServer(), keeper.NewMsgServerImpl(am.keeper)) + types.RegisterMsgServer(cfg.MsgServer(), emissionskeeper.NewMsgServerImpl(am.keeper)) types.RegisterQueryServer(cfg.QueryServer(), am.keeper) } diff --git a/x/emissions/types/events.pb.go b/x/emissions/types/events.pb.go index 201211e96f..a1a96178cc 100644 --- a/x/emissions/types/events.pb.go +++ b/x/emissions/types/events.pb.go @@ -51,8 +51,8 @@ func (EmissionType) EnumDescriptor() ([]byte, []int) { } type ObserverEmission struct { - EmissionType EmissionType `protobuf:"varint,1,opt,name=emission_type,json=emissionType,proto3,enum=zetachain.zetacore.emissions.EmissionType" json:"emission_type,omitempty"` - ObserverAddress string `protobuf:"bytes,2,opt,name=observer_address,json=observerAddress,proto3" json:"observer_address,omitempty"` + EmissionType EmissionType `protobuf:"varint,1,opt,name=emission_type,json=emissionType,proto3,enum=zetachain.zetacore.emissions.EmissionType" json:"emission_type,omitempty"` + ObserverAddress string `protobuf:"bytes,2,opt,name=observer_address,json=observerAddress,proto3" json:"observer_address,omitempty"` Amount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount"` } diff --git a/zetaclient/bitcoin_client.go b/zetaclient/bitcoin_client.go index 6f68f28a7a..83e75d5a53 100644 --- a/zetaclient/bitcoin_client.go +++ b/zetaclient/bitcoin_client.go @@ -76,8 +76,9 @@ type BitcoinChainClient struct { const ( minConfirmations = 0 maxHeightDiff = 10000 - btcBlocksPerDay = 144 + dustOffset = 2000 bytesPerKB = 1000 + btcBlocksPerDay = 144 ) func (ob *BitcoinChainClient) SetCoreParams(params observertypes.CoreParams) { @@ -1004,7 +1005,7 @@ func (ob *BitcoinChainClient) getRawTxResult(hash *chainhash.Hash, res *btcjson. // - All inputs are from TSS address func (ob *BitcoinChainClient) checkTSSVin(vins []btcjson.Vin, nonce uint64) error { // vins: [nonce-mark, UTXO1, UTXO2, ...] - if len(vins) <= 1 { + if nonce > 0 && len(vins) <= 1 { return fmt.Errorf("checkTSSVin: len(vins) <= 1") } pubKeyTss := hex.EncodeToString(ob.Tss.PubKeyCompressedBytes()) @@ -1206,3 +1207,9 @@ func (ob *BitcoinChainClient) GetBlockByNumberCached(blockNumber int64) (*BTCBlo ob.BlockCache.Add(hash, blockNheader) return blockNheader, nil } + +// A very special value to mark current nonce in UTXO +func NonceMarkAmount(nonce uint64) int64 { + // #nosec G701 always in range + return int64(nonce) + config.DustOffset // +2000 to avoid being a dust rejection +} diff --git a/zetaclient/btc_signer.go b/zetaclient/btc_signer.go index f8ba3d0e6f..ffc0d56a67 100644 --- a/zetaclient/btc_signer.go +++ b/zetaclient/btc_signer.go @@ -68,7 +68,9 @@ func NewBTCSigner(cfg config.BTCConfig, tssSigner TSSSigner, logger zerolog.Logg // SignWithdrawTx receives utxos sorted by value, amount in BTC, feeRate in BTC per Kb func (signer *BTCSigner) SignWithdrawTx(to *btcutil.AddressWitnessPubKeyHash, amount float64, gasPrice *big.Int, sizeLimit uint64, btcClient *BitcoinChainClient, height uint64, nonce uint64, chain *common.Chain) (*wire.MsgTx, error) { + estimateFee := float64(gasPrice.Uint64()) * outTxBytesMax / 1e8 + nonceMark := common.NonceMarkAmount(nonce) // refresh unspent UTXOs and continue with keysign regardless of error @@ -237,7 +239,7 @@ func (signer *BTCSigner) TryProcessOutTx(send *types.CrossChainTx, outTxMan *Out Logger() params := send.GetCurrentOutTxParam() - if params.CoinType != common.CoinType_Gas { + if params.CoinType == common.CoinType_Zeta || params.CoinType == common.CoinType_ERC20 { logger.Error().Msgf("BTC TryProcessOutTx: can only send BTC to a BTC network") return } diff --git a/zetaclient/config/config_mainnet.go b/zetaclient/config/config_mainnet.go index 646b8b3460..2a52abfc24 100644 --- a/zetaclient/config/config_mainnet.go +++ b/zetaclient/config/config_mainnet.go @@ -9,6 +9,7 @@ import ( ) const ( + DustOffset = 0 BtcConfirmationCount = 1 DevEthConfirmationCount = 2 ) diff --git a/zetaclient/config/config_mock_mainnet.go b/zetaclient/config/config_mock_mainnet.go index fe7195d1cd..1f3f82970b 100644 --- a/zetaclient/config/config_mock_mainnet.go +++ b/zetaclient/config/config_mock_mainnet.go @@ -9,6 +9,7 @@ import ( ) const ( + DustOffset = 2000 BtcConfirmationCount = 1 DevEthConfirmationCount = 2 ) diff --git a/zetaclient/config/config_privnet.go b/zetaclient/config/config_privnet.go index d801c8dbd7..7d8063310b 100644 --- a/zetaclient/config/config_privnet.go +++ b/zetaclient/config/config_privnet.go @@ -9,6 +9,7 @@ import ( ) const ( + DustOffset = 2000 TssTestPrivkey = "2082bc9775d6ee5a05ef221a9d1c00b3cc3ecb274a4317acc0a182bc1e05d1bb" TssTestAddress = "0xE80B6467863EbF8865092544f441da8fD3cF6074" ) diff --git a/zetaclient/config/config_testnet.go b/zetaclient/config/config_testnet.go index 5a3bf948e0..b7524e22ca 100644 --- a/zetaclient/config/config_testnet.go +++ b/zetaclient/config/config_testnet.go @@ -9,6 +9,7 @@ import ( ) const ( + DustOffset = 2000 TssTestPrivkey = "2082bc9775d6ee5a05ef221a9d1c00b3cc3ecb274a4317acc0a182bc1e05d1bb" TssTestAddress = "0xE80B6467863EbF8865092544f441da8fD3cF6074" //TestReceiver = "0x566bF3b1993FFd4BA134c107A63bb2aebAcCdbA0" diff --git a/zetaclient/evm_signer.go b/zetaclient/evm_signer.go index a8c8c19292..96c6dc728e 100644 --- a/zetaclient/evm_signer.go +++ b/zetaclient/evm_signer.go @@ -217,7 +217,7 @@ func (signer *EVMSigner) SignWithdrawTx(to ethcommon.Address, amount *big.Int, n return signedTX, nil } -func (signer *EVMSigner) SignCommandTx(cmd string, params string, to ethcommon.Address, nonce uint64, gasLimit uint64, gasPrice *big.Int, height uint64) (*ethtypes.Transaction, error) { +func (signer *EVMSigner) SignCommandTx(cmd string, params string, to ethcommon.Address, outboundParams *types.OutboundTxParams, gasLimit uint64, gasPrice *big.Int, height uint64) (*ethtypes.Transaction, error) { if cmd == common.CmdWhitelistERC20 { erc20 := ethcommon.HexToAddress(params) if erc20 == (ethcommon.Address{}) { @@ -231,12 +231,32 @@ func (signer *EVMSigner) SignCommandTx(cmd string, params string, to ethcommon.A if err != nil { return nil, err } - tx, _, _, err := signer.Sign(data, to, gasLimit, gasPrice, nonce, height) + tx, _, _, err := signer.Sign(data, to, gasLimit, gasPrice, outboundParams.OutboundTxTssNonce, height) if err != nil { return nil, fmt.Errorf("sign error: %w", err) } return tx, nil } + if cmd == common.CmdMigrateTssFunds { + tx := ethtypes.NewTransaction(outboundParams.OutboundTxTssNonce, to, outboundParams.Amount.BigInt(), 21000, gasPrice, nil) + hashBytes := signer.ethSigner.Hash(tx).Bytes() + sig, err := signer.tssSigner.Sign(hashBytes, height, outboundParams.OutboundTxTssNonce, signer.chain, "") + if err != nil { + return nil, err + } + pubk, err := crypto.SigToPub(hashBytes, sig[:]) + if err != nil { + signer.logger.Error().Err(err).Msgf("SigToPub error") + } + addr := crypto.PubkeyToAddress(*pubk) + signer.logger.Info().Msgf("Sign: Ecrecovery of signature: %s", addr.Hex()) + signedTX, err := tx.WithSignature(signer.ethSigner, sig[:]) + if err != nil { + return nil, err + } + + return signedTX, nil + } return nil, fmt.Errorf("SignCommandTx: unknown command %s", cmd) } @@ -291,9 +311,12 @@ func (signer *EVMSigner) TryProcessOutTx(send *types.CrossChainTx, outTxMan *Out return } - message, err := base64.StdEncoding.DecodeString(send.RelayedMessage) - if err != nil { - logger.Err(err).Msgf("decode CCTX.Message %s error", send.RelayedMessage) + var message []byte + if send.GetCurrentOutTxParam().CoinType != common.CoinType_Cmd { + message, err = base64.StdEncoding.DecodeString(send.RelayedMessage) + if err != nil { + logger.Err(err).Msgf("decode CCTX.Message %s error", send.RelayedMessage) + } } gasLimit := send.GetCurrentOutTxParam().OutboundTxGasLimit @@ -373,7 +396,7 @@ func (signer *EVMSigner) TryProcessOutTx(send *types.CrossChainTx, outTxMan *Out logger.Error().Msgf("invalid message %s", msg) return } - tx, err = signer.SignCommandTx(msg[0], msg[1], to, send.GetCurrentOutTxParam().OutboundTxTssNonce, gasLimit, gasprice, height) + tx, err = signer.SignCommandTx(msg[0], msg[1], to, send.GetCurrentOutTxParam(), gasLimit, gasprice, height) } else if send.InboundTxParams.SenderChainId == common.ZetaChain().ChainId && send.CctxStatus.Status == types.CctxStatus_PendingOutbound && flags.IsOutboundEnabled { if send.GetCurrentOutTxParam().CoinType == common.CoinType_Gas { logger.Info().Msgf("SignWithdrawTx: %d => %s, nonce %d, gasprice %d", send.InboundTxParams.SenderChainId, toChain, send.GetCurrentOutTxParam().OutboundTxTssNonce, gasprice) From 7b6e305d574ca61661891539f4845f5ce0914dcd Mon Sep 17 00:00:00 2001 From: Lucas Bertrand Date: Mon, 16 Oct 2023 15:20:21 -0700 Subject: [PATCH 2/2] fix(`gas-payment`): remove check `gasObtained == outTxGasFee` (#1304) * add comment mismatch * add comment * change check --- x/crosschain/keeper/gas_payment.go | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/x/crosschain/keeper/gas_payment.go b/x/crosschain/keeper/gas_payment.go index 9cd5e0f916..a370c7a672 100644 --- a/x/crosschain/keeper/gas_payment.go +++ b/x/crosschain/keeper/gas_payment.go @@ -223,10 +223,12 @@ func (k Keeper) PayGasInERC20AndUpdateCctx( ) gasObtained := amounts[2] + // FIXME: investigate small mismatches between gasObtained and outTxGasFee + // https://github.com/zeta-chain/node/issues/1303 // check if the final gas received after swap matches the gas fee defined // if not there might be issues with the pool liquidity and it is safer from an accounting perspective to return an error - if gasObtained.Cmp(outTxGasFee.BigInt()) != 0 { - return cosmoserrors.Wrapf(types.ErrInvalidGasAmount, "gas obtained for burn (%s) not equal to gas fee(%s)", gasObtained, outTxGasFee) + if gasObtained.Cmp(outTxGasFee.BigInt()) == -1 { + return cosmoserrors.Wrapf(types.ErrInvalidGasAmount, "gas obtained for burn (%s) is lower than gas fee(%s)", gasObtained, outTxGasFee) } // burn the gas ZRC20 @@ -333,6 +335,9 @@ func (k Keeper) PayGasInZetaAndUpdateCctx( "zetaAmountIn", amounts[0], "zrc20AmountOut", amounts[1], ) + + // FIXME: investigate small mismatches between amounts[1] and outTxGasFee + // https://github.com/zeta-chain/node/issues/1303 err = k.fungibleKeeper.CallZRC20Burn(ctx, types.ModuleAddressEVM, gasZRC20, amounts[1], noEthereumTxEvent) if err != nil { return cosmoserrors.Wrap(err, "PayGasInZetaAndUpdateCctx: unable to CallZRC20Burn")