diff --git a/app/setup_handlers.go b/app/setup_handlers.go index 18a8ae1f62..b0afa60457 100644 --- a/app/setup_handlers.go +++ b/app/setup_handlers.go @@ -5,7 +5,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" "github.com/cosmos/cosmos-sdk/x/upgrade/types" - observertypes "github.com/zeta-chain/zetacore/x/observer/types" + crosschaintypes "github.com/zeta-chain/zetacore/x/crosschain/types" ) const releaseVersion = "v10.1.0" @@ -17,7 +17,7 @@ func SetupHandlers(app *App) { for m, mb := range app.mm.Modules { vm[m] = mb.ConsensusVersion() } - vm[observertypes.ModuleName] = vm[observertypes.ModuleName] - 1 + vm[crosschaintypes.ModuleName] = vm[crosschaintypes.ModuleName] - 1 return app.mm.RunMigrations(ctx, app.configurator, vm) }) diff --git a/changelog.md b/changelog.md index bb313bed7a..914ce81992 100644 --- a/changelog.md +++ b/changelog.md @@ -3,6 +3,7 @@ ## Unreleased ### Features +* [1395](https://github.com/zeta-chain/node/pull/1395) - Add state variable to track aborted zeta amount * [1387](https://github.com/zeta-chain/node/pull/1387) - Add HSM capability for zetaclient hot key ### Fixes diff --git a/docs/cli/zetacored/zetacored_query_crosschain.md b/docs/cli/zetacored/zetacored_query_crosschain.md index 0ccdb37d15..d016bef76c 100644 --- a/docs/cli/zetacored/zetacored_query_crosschain.md +++ b/docs/cli/zetacored/zetacored_query_crosschain.md @@ -26,6 +26,7 @@ zetacored query crosschain [flags] * [zetacored query](zetacored_query.md) - Querying subcommands * [zetacored query crosschain get-tss-address](zetacored_query_crosschain_get-tss-address.md) - Query current tss address +* [zetacored query crosschain get-zeta-accounting](zetacored_query_crosschain_get-zeta-accounting.md) - Query zeta accounting * [zetacored query crosschain in-tx-hash-to-cctx-data](zetacored_query_crosschain_in-tx-hash-to-cctx-data.md) - query a cctx data from a in tx hash * [zetacored query crosschain last-zeta-height](zetacored_query_crosschain_last-zeta-height.md) - Query last Zeta Height * [zetacored query crosschain list-all-in-tx-trackers](zetacored_query_crosschain_list-all-in-tx-trackers.md) - shows all inTxTrackers diff --git a/docs/cli/zetacored/zetacored_query_crosschain_get-zeta-accounting.md b/docs/cli/zetacored/zetacored_query_crosschain_get-zeta-accounting.md new file mode 100644 index 0000000000..589865d868 --- /dev/null +++ b/docs/cli/zetacored/zetacored_query_crosschain_get-zeta-accounting.md @@ -0,0 +1,33 @@ +# query crosschain get-zeta-accounting + +Query zeta accounting + +``` +zetacored query crosschain get-zeta-accounting [flags] +``` + +### Options + +``` + --grpc-addr string the gRPC endpoint to use for this chain + --grpc-insecure allow gRPC over insecure channels, if not TLS the server must use TLS + --height int Use a specific height to query state at (this can error if the node is pruning state) + -h, --help help for get-zeta-accounting + --node string [host]:[port] to Tendermint RPC interface for this chain + -o, --output string Output format (text|json) +``` + +### Options inherited from parent commands + +``` + --chain-id string The network chain ID + --home string directory for config and data + --log_format string The logging format (json|plain) + --log_level string The logging level (trace|debug|info|warn|error|fatal|panic) + --trace print out full stack trace on errors +``` + +### SEE ALSO + +* [zetacored query crosschain](zetacored_query_crosschain.md) - Querying commands for the crosschain module + diff --git a/docs/openapi/openapi.swagger.yaml b/docs/openapi/openapi.swagger.yaml index 0256fdc9e7..4c911592e1 100644 --- a/docs/openapi/openapi.swagger.yaml +++ b/docs/openapi/openapi.swagger.yaml @@ -27369,6 +27369,20 @@ paths: $ref: '#/definitions/googlerpcStatus' tags: - Query + /zeta-chain/crosschain/zetaAccounting: + get: + operationId: Query_ZetaAccounting + responses: + "200": + description: A successful response. + schema: + $ref: '#/definitions/crosschainQueryZetaAccountingResponse' + default: + description: An unexpected error response. + schema: + $ref: '#/definitions/googlerpcStatus' + tags: + - Query /zeta-chain/emissions/get_emissions_factors: get: summary: Queries a list of GetEmmisonsFactors items. @@ -50952,6 +50966,15 @@ definitions: items: type: object $ref: '#/definitions/crosschainTSS' + crosschainQueryZetaAccountingResponse: + type: object + properties: + aborted_zeta_amount: + type: string + aborted_gas_amount: + type: string + aborted_erc20_amount: + type: string crosschainTSS: type: object properties: diff --git a/go.mod b/go.mod index 30b1abe989..ce3fec1c3a 100644 --- a/go.mod +++ b/go.mod @@ -84,6 +84,7 @@ require ( github.com/jmhodges/levigo v1.0.0 // indirect github.com/libp2p/go-yamux/v4 v4.0.0 // indirect github.com/linxGnu/grocksdb v1.7.15 // indirect + github.com/nbutton23/zxcvbn-go v0.0.0-20210217022336-fa2cb2858354 // indirect github.com/miekg/pkcs11 v1.1.1 // indirect github.com/onsi/ginkgo/v2 v2.9.7 // indirect github.com/prometheus/tsdb v0.7.1 // indirect @@ -94,6 +95,7 @@ require ( github.com/quic-go/webtransport-go v0.5.3 // indirect github.com/rjeczalik/notify v0.9.1 // indirect github.com/russross/blackfriday/v2 v2.1.0 // indirect + github.com/securego/gosec v0.0.0-20200401082031-e946c8c39989 // indirect github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c // indirect github.com/thales-e-security/pool v0.0.2 // indirect github.com/tidwall/gjson v1.14.4 // indirect diff --git a/go.sum b/go.sum index 77802118ff..5cae979ab5 100644 --- a/go.sum +++ b/go.sum @@ -1851,6 +1851,7 @@ github.com/ipfs/go-datastore v0.6.0/go.mod h1:rt5M3nNbSO/8q1t4LNkLyUwRs8HupMeN/8 github.com/ipfs/go-detect-race v0.0.1 h1:qX/xay2W3E4Q1U7d9lNs1sU9nvguX0a7319XbyQ6cOk= github.com/ipfs/go-detect-race v0.0.1/go.mod h1:8BNT7shDZPo99Q74BpGMK+4D8Mn4j46UU0LZ723meps= github.com/ipfs/go-ipfs-util v0.0.2 h1:59Sswnk1MFaiq+VcaknX7aYEyGyGDAA73ilhEK2POp8= +github.com/ipfs/go-ipfs-util v0.0.2/go.mod h1:CbPtkWJzjLdEcezDns2XYaehFVNXG9zrdrtMecczcsQ= github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= github.com/ipfs/go-log v1.0.5 h1:2dOuUCB1Z7uoczMWgAyDck5JLb72zHzrMnGnCNNbvY8= github.com/ipfs/go-log v1.0.5/go.mod h1:j0b8ZoR+7+R99LD9jZ6+AJsrzkPbSXbZfGakb5JPtIo= @@ -2335,6 +2336,7 @@ github.com/nats-io/nkeys v0.2.0/go.mod h1:XdZpAbhgyyODYqjTawOnIOI7VlbKSarI9Gfy1t github.com/nats-io/nkeys v0.3.0/go.mod h1:gvUNGjVcM2IPr5rCsRsC6Wb3Hr2CQAm08dsxtV6A5y4= github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= github.com/nbutton23/zxcvbn-go v0.0.0-20180912185939-ae427f1e4c1d/go.mod h1:o96djdrsSGy3AWPyBgZMAGfxZNfgntdJG+11KU4QvbU= +github.com/nbutton23/zxcvbn-go v0.0.0-20210217022336-fa2cb2858354 h1:4kuARK6Y6FxaNu/BnU2OAaLF86eTVhP2hjTB6iMvItA= github.com/nbutton23/zxcvbn-go v0.0.0-20210217022336-fa2cb2858354/go.mod h1:KSVJerMDfblTH7p5MZaTt+8zaT2iEk3AkVb9PQdZuE8= github.com/ncw/swift v1.0.47/go.mod h1:23YIA4yWVnGwv2dQlN4bB7egfYX6YLn0Yo/S6zZO/ZM= github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86/go.mod h1:kHJEU3ofeGjhHklVoIGuVj85JJwZ6kWPaJwCIxgnFmo= @@ -2690,6 +2692,7 @@ github.com/seccomp/libseccomp-golang v0.9.1/go.mod h1:GbW5+tmTXfcxTToHLXlScSlAvW github.com/seccomp/libseccomp-golang v0.9.2-0.20210429002308-3879420cc921/go.mod h1:JA8cRccbGaA1s33RQf7Y1+q9gHmZX1yB/z9WDN1C6fg= github.com/seccomp/libseccomp-golang v0.9.2-0.20220502022130-f33da4d89646/go.mod h1:JA8cRccbGaA1s33RQf7Y1+q9gHmZX1yB/z9WDN1C6fg= github.com/securego/gosec v0.0.0-20200103095621-79fbf3af8d83/go.mod h1:vvbZ2Ae7AzSq3/kywjUDxSNq2SJ27RxCz2un0H3ePqE= +github.com/securego/gosec v0.0.0-20200401082031-e946c8c39989 h1:rq2/kILQnPtq5oL4+IAjgVOjh5e2yj2aaCYi7squEvI= github.com/securego/gosec v0.0.0-20200401082031-e946c8c39989/go.mod h1:i9l/TNj+yDFh9SZXUTvspXTjbFXgZGP/UvhU1S65A4A= github.com/securego/gosec/v2 v2.3.0/go.mod h1:UzeVyUXbxukhLeHKV3VVqo7HdoQR9MrRfFmZYotn8ME= github.com/securego/gosec/v2 v2.13.1/go.mod h1:EO1sImBMBWFjOTFzMWfTRrZW6M15gm60ljzrmy/wtHo= @@ -2764,6 +2767,7 @@ github.com/sourcegraph/go-diff v0.5.1/go.mod h1:j2dHj3m8aZgQO8lMTcTnBcXkRRRqi34c github.com/sourcegraph/go-diff v0.5.3/go.mod h1:v9JDtjCE4HHHCZGId75rg8gkKKa98RVjBcBGsVmMmak= github.com/sourcegraph/go-diff v0.6.1/go.mod h1:iBszgVvyxdc8SFZ7gm69go2KDdt3ag071iBaWPF6cjs= github.com/sourcegraph/syntaxhighlight v0.0.0-20170531221838-bd320f5d308e/go.mod h1:HuIsMU8RRBOtsCgI77wP899iHVBQpCmg4ErYMZB+2IA= +github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572/go.mod h1:w0SWMsp6j9O/dk4/ZpIhL+3CkG8ofA2vuv7k+ltqUMc= github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= diff --git a/proto/crosschain/cross_chain_tx.proto b/proto/crosschain/cross_chain_tx.proto index fd2851af79..1dfe0593aa 100644 --- a/proto/crosschain/cross_chain_tx.proto +++ b/proto/crosschain/cross_chain_tx.proto @@ -32,6 +32,21 @@ message InboundTxParams { uint64 inbound_tx_finalized_zeta_height = 10; } +message ZetaAccounting { + string aborted_zeta_amount = 1 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Uint", + (gogoproto.nullable) = false + ]; // This stores the total aborted amount for cctx of coin-type ZETA + string aborted_gas_amount = 2 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Uint", + (gogoproto.nullable) = false + ]; // This stores the total aborted amount for cctx of coin-type GAS + string aborted_erc20_amount = 3 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Uint", + (gogoproto.nullable) = false + ]; // This stores the total aborted amount for cctx of coin-type ERC20 +} + message OutboundTxParams { string receiver = 1; int64 receiver_chainId = 2; diff --git a/proto/crosschain/genesis.proto b/proto/crosschain/genesis.proto index c62d228d0b..98ccc4fb1c 100644 --- a/proto/crosschain/genesis.proto +++ b/proto/crosschain/genesis.proto @@ -27,4 +27,5 @@ message GenesisState { repeated InTxHashToCctx inTxHashToCctxList = 9 [(gogoproto.nullable) = false]; repeated TSS tss_history = 10 [(gogoproto.nullable) = false]; repeated InTxTracker in_tx_tracker_list = 11 [(gogoproto.nullable) = false]; + ZetaAccounting zeta_accounting = 12 [(gogoproto.nullable) = false]; } diff --git a/proto/crosschain/query.proto b/proto/crosschain/query.proto index 4ba5849353..f499f67932 100644 --- a/proto/crosschain/query.proto +++ b/proto/crosschain/query.proto @@ -147,6 +147,18 @@ service Query { rpc CctxByStatus(QueryCctxByStatusRequest) returns (QueryCctxByStatusResponse) { option (google.api.http).get = "/zeta-chain/crosschain/cctxbyStatus/{status}"; } + + rpc ZetaAccounting(QueryZetaAccountingRequest) returns (QueryZetaAccountingResponse) { + option (google.api.http).get = "/zeta-chain/crosschain/zetaAccounting"; + } +} + +message QueryZetaAccountingRequest {} + +message QueryZetaAccountingResponse { + string aborted_zeta_amount = 1; + string aborted_gas_amount = 2; + string aborted_erc20_amount = 3; } message QueryCctxByStatusRequest { diff --git a/typescript/crosschain/cross_chain_tx_pb.d.ts b/typescript/crosschain/cross_chain_tx_pb.d.ts index 3d4934dc05..5310c270d6 100644 --- a/typescript/crosschain/cross_chain_tx_pb.d.ts +++ b/typescript/crosschain/cross_chain_tx_pb.d.ts @@ -129,6 +129,46 @@ export declare class InboundTxParams extends Message { static equals(a: InboundTxParams | PlainMessage | undefined, b: InboundTxParams | PlainMessage | undefined): boolean; } +/** + * @generated from message zetachain.zetacore.crosschain.ZetaAccounting + */ +export declare class ZetaAccounting extends Message { + /** + * This stores the total aborted amount for cctx of coin-type ZETA + * + * @generated from field: string aborted_zeta_amount = 1; + */ + abortedZetaAmount: string; + + /** + * This stores the total aborted amount for cctx of coin-type GAS + * + * @generated from field: string aborted_gas_amount = 2; + */ + abortedGasAmount: string; + + /** + * This stores the total aborted amount for cctx of coin-type ERC20 + * + * @generated from field: string aborted_erc20_amount = 3; + */ + abortedErc20Amount: string; + + constructor(data?: PartialMessage); + + static readonly runtime: typeof proto3; + static readonly typeName = "zetachain.zetacore.crosschain.ZetaAccounting"; + static readonly fields: FieldList; + + static fromBinary(bytes: Uint8Array, options?: Partial): ZetaAccounting; + + static fromJson(jsonValue: JsonValue, options?: Partial): ZetaAccounting; + + static fromJsonString(jsonString: string, options?: Partial): ZetaAccounting; + + static equals(a: ZetaAccounting | PlainMessage | undefined, b: ZetaAccounting | PlainMessage | undefined): boolean; +} + /** * @generated from message zetachain.zetacore.crosschain.OutboundTxParams */ diff --git a/typescript/crosschain/genesis_pb.d.ts b/typescript/crosschain/genesis_pb.d.ts index b08be54a4a..3011e901cc 100644 --- a/typescript/crosschain/genesis_pb.d.ts +++ b/typescript/crosschain/genesis_pb.d.ts @@ -10,7 +10,7 @@ import type { OutTxTracker } from "./out_tx_tracker_pb.js"; import type { TSS } from "./tss_pb.js"; import type { GasPrice } from "./gas_price_pb.js"; import type { ChainNonces } from "./chain_nonces_pb.js"; -import type { CrossChainTx } from "./cross_chain_tx_pb.js"; +import type { CrossChainTx, ZetaAccounting } from "./cross_chain_tx_pb.js"; import type { LastBlockHeight } from "./last_block_height_pb.js"; import type { InTxHashToCctx } from "./in_tx_hash_to_cctx_pb.js"; import type { InTxTracker } from "./in_tx_tracker_pb.js"; @@ -71,6 +71,11 @@ export declare class GenesisState extends Message { */ inTxTrackerList: InTxTracker[]; + /** + * @generated from field: zetachain.zetacore.crosschain.ZetaAccounting zeta_accounting = 12; + */ + zetaAccounting?: ZetaAccounting; + constructor(data?: PartialMessage); static readonly runtime: typeof proto3; diff --git a/typescript/crosschain/query_pb.d.ts b/typescript/crosschain/query_pb.d.ts index 2176ad0a5f..fa5ea0a44a 100644 --- a/typescript/crosschain/query_pb.d.ts +++ b/typescript/crosschain/query_pb.d.ts @@ -17,6 +17,59 @@ import type { ChainNonces } from "./chain_nonces_pb.js"; import type { PendingNonces } from "./nonce_to_cctx_pb.js"; import type { LastBlockHeight } from "./last_block_height_pb.js"; +/** + * @generated from message zetachain.zetacore.crosschain.QueryZetaAccountingRequest + */ +export declare class QueryZetaAccountingRequest extends Message { + constructor(data?: PartialMessage); + + static readonly runtime: typeof proto3; + static readonly typeName = "zetachain.zetacore.crosschain.QueryZetaAccountingRequest"; + static readonly fields: FieldList; + + static fromBinary(bytes: Uint8Array, options?: Partial): QueryZetaAccountingRequest; + + static fromJson(jsonValue: JsonValue, options?: Partial): QueryZetaAccountingRequest; + + static fromJsonString(jsonString: string, options?: Partial): QueryZetaAccountingRequest; + + static equals(a: QueryZetaAccountingRequest | PlainMessage | undefined, b: QueryZetaAccountingRequest | PlainMessage | undefined): boolean; +} + +/** + * @generated from message zetachain.zetacore.crosschain.QueryZetaAccountingResponse + */ +export declare class QueryZetaAccountingResponse extends Message { + /** + * @generated from field: string aborted_zeta_amount = 1; + */ + abortedZetaAmount: string; + + /** + * @generated from field: string aborted_gas_amount = 2; + */ + abortedGasAmount: string; + + /** + * @generated from field: string aborted_erc20_amount = 3; + */ + abortedErc20Amount: string; + + constructor(data?: PartialMessage); + + static readonly runtime: typeof proto3; + static readonly typeName = "zetachain.zetacore.crosschain.QueryZetaAccountingResponse"; + static readonly fields: FieldList; + + static fromBinary(bytes: Uint8Array, options?: Partial): QueryZetaAccountingResponse; + + static fromJson(jsonValue: JsonValue, options?: Partial): QueryZetaAccountingResponse; + + static fromJsonString(jsonString: string, options?: Partial): QueryZetaAccountingResponse; + + static equals(a: QueryZetaAccountingResponse | PlainMessage | undefined, b: QueryZetaAccountingResponse | PlainMessage | undefined): boolean; +} + /** * @generated from message zetachain.zetacore.crosschain.QueryCctxByStatusRequest */ diff --git a/x/crosschain/client/cli/query.go b/x/crosschain/client/cli/query.go index 21b112a621..57bfab7741 100644 --- a/x/crosschain/client/cli/query.go +++ b/x/crosschain/client/cli/query.go @@ -46,6 +46,7 @@ func GetQueryCmd(_ string) *cobra.Command { CmdPendingCctx(), CmdListInTxTrackerByChain(), CmdListInTxTrackers(), + CmdGetZetaAccounting(), ) return cmd diff --git a/x/crosschain/client/cli/query_zeta_accounting.go b/x/crosschain/client/cli/query_zeta_accounting.go new file mode 100644 index 0000000000..aece6e6f37 --- /dev/null +++ b/x/crosschain/client/cli/query_zeta_accounting.go @@ -0,0 +1,31 @@ +package cli + +import ( + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/spf13/cobra" + "github.com/zeta-chain/zetacore/x/crosschain/types" +) + +func CmdGetZetaAccounting() *cobra.Command { + cmd := &cobra.Command{ + Use: "get-zeta-accounting", + Short: "Query zeta accounting", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, args []string) (err error) { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + queryClient := types.NewQueryClient(clientCtx) + params := &types.QueryZetaAccountingRequest{} + res, err := queryClient.ZetaAccounting(cmd.Context(), params) + if err != nil { + return err + } + return clientCtx.PrintProto(res) + }, + } + flags.AddQueryFlagsToCmd(cmd) + return cmd +} diff --git a/x/crosschain/genesis.go b/x/crosschain/genesis.go index 9c0f52bb29..e75715ad07 100644 --- a/x/crosschain/genesis.go +++ b/x/crosschain/genesis.go @@ -13,6 +13,7 @@ func InitGenesis(ctx sdk.Context, k keeper.Keeper, genState types.GenesisState) // Params k.SetParams(ctx, genState.Params) + k.SetZetaAccounting(ctx, genState.ZetaAccounting) // Set all the outTxTracker for _, elem := range genState.OutTxTrackerList { k.SetOutTxTracker(ctx, elem) @@ -70,6 +71,7 @@ func InitGenesis(ctx sdk.Context, k keeper.Keeper, genState types.GenesisState) k.SetTSSHistory(ctx, elem) } } + } // ExportGenesis returns the crosschain module's exported genesis. @@ -116,6 +118,10 @@ func ExportGenesis(ctx sdk.Context, k keeper.Keeper) *types.GenesisState { } genesis.TssHistory = k.GetAllTSS(ctx) + amount, found := k.GetZetaAccounting(ctx) + if found { + genesis.ZetaAccounting = amount + } return &genesis } diff --git a/x/crosschain/genesis_test.go b/x/crosschain/genesis_test.go index 994c83f67a..8fc5612a99 100644 --- a/x/crosschain/genesis_test.go +++ b/x/crosschain/genesis_test.go @@ -3,6 +3,7 @@ package crosschain_test import ( "testing" + sdkmath "cosmossdk.io/math" "github.com/stretchr/testify/require" keepertest "github.com/zeta-chain/zetacore/testutil/keeper" "github.com/zeta-chain/zetacore/testutil/nullify" @@ -14,6 +15,9 @@ import ( func TestGenesis(t *testing.T) { genesisState := types.GenesisState{ Params: types.DefaultParams(), + ZetaAccounting: types.ZetaAccounting{ + AbortedZetaAmount: sdkmath.OneUint(), + }, OutTxTrackerList: []types.OutTxTracker{ sample.OutTxTracker(t, "0"), sample.OutTxTracker(t, "1"), diff --git a/x/crosschain/keeper/gas_payment.go b/x/crosschain/keeper/gas_payment.go index a370c7a672..913af966c3 100644 --- a/x/crosschain/keeper/gas_payment.go +++ b/x/crosschain/keeper/gas_payment.go @@ -21,7 +21,7 @@ import ( // **Caller should feed temporary ctx into this function** func (k Keeper) PayGasAndUpdateCctx( ctx sdk.Context, - chainID int64, + chainID int64, // Chain Id is the outbound chain chain id , this can be receiver chain for regular transactions and sender-chain to reverted transactions cctx *types.CrossChainTx, inputAmount math.Uint, noEthereumTxEvent bool, diff --git a/x/crosschain/keeper/grpc_query_cctx.go b/x/crosschain/keeper/grpc_query_cctx.go new file mode 100644 index 0000000000..c2c469acf3 --- /dev/null +++ b/x/crosschain/keeper/grpc_query_cctx.go @@ -0,0 +1,163 @@ +package keeper + +import ( + "context" + "fmt" + + "github.com/cosmos/cosmos-sdk/store/prefix" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/query" + "github.com/zeta-chain/zetacore/x/crosschain/types" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" +) + +func (k Keeper) ZetaAccounting(c context.Context, _ *types.QueryZetaAccountingRequest) (*types.QueryZetaAccountingResponse, error) { + ctx := sdk.UnwrapSDKContext(c) + amount, found := k.GetZetaAccounting(ctx) + if !found { + return nil, status.Error(codes.Internal, "aborted zeta amount not found") + } + return &types.QueryZetaAccountingResponse{ + AbortedZetaAmount: amount.AbortedZetaAmount.String(), + AbortedGasAmount: amount.AbortedGasAmount.String(), + AbortedErc20Amount: amount.AbortedErc20Amount.String(), + }, nil +} + +func (k Keeper) CctxAll(c context.Context, req *types.QueryAllCctxRequest) (*types.QueryAllCctxResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + var sends []*types.CrossChainTx + ctx := sdk.UnwrapSDKContext(c) + + store := ctx.KVStore(k.storeKey) + sendStore := prefix.NewStore(store, types.KeyPrefix(types.SendKey)) + + pageRes, err := query.Paginate(sendStore, req.Pagination, func(key []byte, value []byte) error { + var send types.CrossChainTx + if err := k.cdc.Unmarshal(value, &send); err != nil { + return err + } + sends = append(sends, &send) + return nil + }) + + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + return &types.QueryAllCctxResponse{CrossChainTx: sends, Pagination: pageRes}, nil +} + +func (k Keeper) CctxByStatus(c context.Context, req *types.QueryCctxByStatusRequest) (*types.QueryCctxByStatusResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + ctx := sdk.UnwrapSDKContext(c) + p := types.KeyPrefix(fmt.Sprintf("%s", types.SendKey)) + store := prefix.NewStore(ctx.KVStore(k.storeKey), p) + + iterator := sdk.KVStorePrefixIterator(store, []byte{}) + + defer iterator.Close() + cctxList := make([]types.CrossChainTx, 0) + for ; iterator.Valid(); iterator.Next() { + var val types.CrossChainTx + k.cdc.MustUnmarshal(iterator.Value(), &val) + if val.CctxStatus.Status == req.Status { + cctxList = append(cctxList, val) + } + } + + return &types.QueryCctxByStatusResponse{CrossChainTx: cctxList}, nil +} + +func (k Keeper) Cctx(c context.Context, req *types.QueryGetCctxRequest) (*types.QueryGetCctxResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + ctx := sdk.UnwrapSDKContext(c) + + val, found := k.GetCrossChainTx(ctx, req.Index) + if !found { + return nil, status.Error(codes.InvalidArgument, "not found") + } + + return &types.QueryGetCctxResponse{CrossChainTx: &val}, nil +} + +func (k Keeper) CctxByNonce(c context.Context, req *types.QueryGetCctxByNonceRequest) (*types.QueryGetCctxResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + ctx := sdk.UnwrapSDKContext(c) + tss, found := k.GetTSS(ctx) + if !found { + return nil, status.Error(codes.Internal, "tss not found") + } + // #nosec G701 always in range + res, found := k.GetNonceToCctx(ctx, tss.TssPubkey, req.ChainID, int64(req.Nonce)) + if !found { + return nil, status.Error(codes.Internal, fmt.Sprintf("nonceToCctx not found: nonce %d, chainid %d", req.Nonce, req.ChainID)) + } + val, found := k.GetCrossChainTx(ctx, res.CctxIndex) + if !found { + return nil, status.Error(codes.Internal, fmt.Sprintf("cctx not found: index %s", res.CctxIndex)) + } + + return &types.QueryGetCctxResponse{CrossChainTx: &val}, nil +} + +func (k Keeper) CctxAllPending(c context.Context, req *types.QueryAllCctxPendingRequest) (*types.QueryAllCctxPendingResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + ctx := sdk.UnwrapSDKContext(c) + tss, found := k.GetTSS(ctx) + if !found { + return nil, status.Error(codes.Internal, "tss not found") + } + p, found := k.GetPendingNonces(ctx, tss.TssPubkey, req.ChainId) + if !found { + return nil, status.Error(codes.Internal, "pending nonces not found") + } + sends := make([]*types.CrossChainTx, 0) + + // now query the previous nonces up to 100 prior to find any pending cctx that we might have missed + // need this logic because a confirmation of higher nonce will automatically update the p.NonceLow + // therefore might mask some lower nonce cctx that is still pending. + startNonce := p.NonceLow - 1000 + if startNonce < 0 { + startNonce = 0 + } + for i := startNonce; i < p.NonceLow; i++ { + res, found := k.GetNonceToCctx(ctx, tss.TssPubkey, req.ChainId, i) + if !found { + return nil, status.Error(codes.Internal, fmt.Sprintf("nonceToCctx not found: nonce %d, chainid %d", i, req.ChainId)) + } + send, found := k.GetCrossChainTx(ctx, res.CctxIndex) + if !found { + return nil, status.Error(codes.Internal, fmt.Sprintf("cctx not found: index %s", res.CctxIndex)) + } + if send.CctxStatus.Status == types.CctxStatus_PendingOutbound || send.CctxStatus.Status == types.CctxStatus_PendingRevert { + sends = append(sends, &send) + } + } + + // now query the pending nonces that we know are pending + for i := p.NonceLow; i < p.NonceHigh; i++ { + ntc, found := k.GetNonceToCctx(ctx, tss.TssPubkey, req.ChainId, i) + if !found { + return nil, status.Error(codes.Internal, "nonceToCctx not found") + } + cctx, found := k.GetCrossChainTx(ctx, ntc.CctxIndex) + if !found { + return nil, status.Error(codes.Internal, "cctxIndex not found") + } + sends = append(sends, &cctx) + } + + return &types.QueryAllCctxPendingResponse{CrossChainTx: sends}, nil +} diff --git a/x/crosschain/keeper/keeper.go b/x/crosschain/keeper/keeper.go index 0a44254be7..877bd56016 100644 --- a/x/crosschain/keeper/keeper.go +++ b/x/crosschain/keeper/keeper.go @@ -81,3 +81,15 @@ func (k Keeper) GetFungibleKeeper() types.FungibleKeeper { func (k Keeper) GetObserverKeeper() types.ZetaObserverKeeper { return k.zetaObserverKeeper } + +func (k Keeper) GetStoreKey() storetypes.StoreKey { + return k.storeKey +} + +func (k Keeper) GetMemKey() storetypes.StoreKey { + return k.memKey +} + +func (k Keeper) GetCodec() codec.Codec { + return k.cdc +} diff --git a/x/crosschain/keeper/keeper_cross_chain_tx.go b/x/crosschain/keeper/keeper_cross_chain_tx.go index 55da65fb9d..18e13aec21 100644 --- a/x/crosschain/keeper/keeper_cross_chain_tx.go +++ b/x/crosschain/keeper/keeper_cross_chain_tx.go @@ -1,26 +1,22 @@ package keeper import ( - "context" "fmt" "cosmossdk.io/math" "github.com/cosmos/cosmos-sdk/store/prefix" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/types/query" "github.com/zeta-chain/zetacore/common" "github.com/zeta-chain/zetacore/x/crosschain/types" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" ) -// SetCctxAndNonceToCctxAndInTxHashToCctx set a specific send in the store from its index -func (k Keeper) SetCctxAndNonceToCctxAndInTxHashToCctx(ctx sdk.Context, send types.CrossChainTx) { +// SetCctxAndNonceToCctxAndInTxHashToCctx does the following things in one function: +// 1. set the cctx in the store +// 2. set the mapping inTxHash -> cctxIndex , one inTxHash can be connected to multiple cctxindex +// 3. set the mapping nonce => cctx - p := types.KeyPrefix(fmt.Sprintf("%s", types.SendKey)) - store := prefix.NewStore(ctx.KVStore(k.storeKey), p) - b := k.cdc.MustMarshal(&send) - store.Set(types.KeyPrefix(send.Index), b) +func (k Keeper) SetCctxAndNonceToCctxAndInTxHashToCctx(ctx sdk.Context, send types.CrossChainTx) { + k.SetCrossChainTx(ctx, send) // set mapping inTxHash -> cctxIndex in, _ := k.GetInTxHashToCctx(ctx, send.InboundTxParams.InboundTxObservedHash) @@ -51,6 +47,19 @@ func (k Keeper) SetCctxAndNonceToCctxAndInTxHashToCctx(ctx sdk.Context, send typ Tss: tss.TssPubkey, }) } + if send.CctxStatus.Status == types.CctxStatus_Aborted { + switch send.GetCurrentOutTxParam().CoinType { + case common.CoinType_Zeta: + k.AddZetaAbortedAmount(ctx, send.GetCurrentOutTxParam().Amount) + case common.CoinType_Gas: + k.AddGasAbortedAmount(ctx, send.GetCurrentOutTxParam().Amount) + case common.CoinType_ERC20: + k.AddErc20AbortedAmount(ctx, send.GetCurrentOutTxParam().Amount) + default: + ctx.Logger().Error(fmt.Sprintf("unknown coin type %s", send.GetCurrentOutTxParam().CoinType)) + return + } + } } // SetCrossChainTx set a specific send in the store from its index @@ -101,143 +110,6 @@ func (k Keeper) RemoveCrossChainTx(ctx sdk.Context, index string) { // Queries -func (k Keeper) CctxAll(c context.Context, req *types.QueryAllCctxRequest) (*types.QueryAllCctxResponse, error) { - if req == nil { - return nil, status.Error(codes.InvalidArgument, "invalid request") - } - var sends []*types.CrossChainTx - ctx := sdk.UnwrapSDKContext(c) - - store := ctx.KVStore(k.storeKey) - sendStore := prefix.NewStore(store, types.KeyPrefix(types.SendKey)) - - pageRes, err := query.Paginate(sendStore, req.Pagination, func(key []byte, value []byte) error { - var send types.CrossChainTx - if err := k.cdc.Unmarshal(value, &send); err != nil { - return err - } - sends = append(sends, &send) - return nil - }) - - if err != nil { - return nil, status.Error(codes.Internal, err.Error()) - } - - return &types.QueryAllCctxResponse{CrossChainTx: sends, Pagination: pageRes}, nil -} - -func (k Keeper) CctxByStatus(c context.Context, req *types.QueryCctxByStatusRequest) (*types.QueryCctxByStatusResponse, error) { - if req == nil { - return nil, status.Error(codes.InvalidArgument, "invalid request") - } - ctx := sdk.UnwrapSDKContext(c) - p := types.KeyPrefix(fmt.Sprintf("%s", types.SendKey)) - store := prefix.NewStore(ctx.KVStore(k.storeKey), p) - - iterator := sdk.KVStorePrefixIterator(store, []byte{}) - - defer iterator.Close() - cctxList := make([]types.CrossChainTx, 0) - for ; iterator.Valid(); iterator.Next() { - var val types.CrossChainTx - k.cdc.MustUnmarshal(iterator.Value(), &val) - if val.CctxStatus.Status == req.Status { - cctxList = append(cctxList, val) - } - } - - return &types.QueryCctxByStatusResponse{CrossChainTx: cctxList}, nil -} - -func (k Keeper) Cctx(c context.Context, req *types.QueryGetCctxRequest) (*types.QueryGetCctxResponse, error) { - if req == nil { - return nil, status.Error(codes.InvalidArgument, "invalid request") - } - ctx := sdk.UnwrapSDKContext(c) - - val, found := k.GetCrossChainTx(ctx, req.Index) - if !found { - return nil, status.Error(codes.InvalidArgument, "not found") - } - - return &types.QueryGetCctxResponse{CrossChainTx: &val}, nil -} - -func (k Keeper) CctxByNonce(c context.Context, req *types.QueryGetCctxByNonceRequest) (*types.QueryGetCctxResponse, error) { - if req == nil { - return nil, status.Error(codes.InvalidArgument, "invalid request") - } - ctx := sdk.UnwrapSDKContext(c) - tss, found := k.GetTSS(ctx) - if !found { - return nil, status.Error(codes.Internal, "tss not found") - } - // #nosec G701 always in range - res, found := k.GetNonceToCctx(ctx, tss.TssPubkey, req.ChainID, int64(req.Nonce)) - if !found { - return nil, status.Error(codes.Internal, fmt.Sprintf("nonceToCctx not found: nonce %d, chainid %d", req.Nonce, req.ChainID)) - } - val, found := k.GetCrossChainTx(ctx, res.CctxIndex) - if !found { - return nil, status.Error(codes.Internal, fmt.Sprintf("cctx not found: index %s", res.CctxIndex)) - } - - return &types.QueryGetCctxResponse{CrossChainTx: &val}, nil -} - -func (k Keeper) CctxAllPending(c context.Context, req *types.QueryAllCctxPendingRequest) (*types.QueryAllCctxPendingResponse, error) { - if req == nil { - return nil, status.Error(codes.InvalidArgument, "invalid request") - } - ctx := sdk.UnwrapSDKContext(c) - tss, found := k.GetTSS(ctx) - if !found { - return nil, status.Error(codes.Internal, "tss not found") - } - p, found := k.GetPendingNonces(ctx, tss.TssPubkey, req.ChainId) - if !found { - return nil, status.Error(codes.Internal, "pending nonces not found") - } - sends := make([]*types.CrossChainTx, 0) - - // now query the previous nonces up to 100 prior to find any pending cctx that we might have missed - // need this logic because a confirmation of higher nonce will automatically update the p.NonceLow - // therefore might mask some lower nonce cctx that is still pending. - startNonce := p.NonceLow - 1000 - if startNonce < 0 { - startNonce = 0 - } - for i := startNonce; i < p.NonceLow; i++ { - res, found := k.GetNonceToCctx(ctx, tss.TssPubkey, req.ChainId, i) - if !found { - return nil, status.Error(codes.Internal, fmt.Sprintf("nonceToCctx not found: nonce %d, chainid %d", i, req.ChainId)) - } - send, found := k.GetCrossChainTx(ctx, res.CctxIndex) - if !found { - return nil, status.Error(codes.Internal, fmt.Sprintf("cctx not found: index %s", res.CctxIndex)) - } - if send.CctxStatus.Status == types.CctxStatus_PendingOutbound || send.CctxStatus.Status == types.CctxStatus_PendingRevert { - sends = append(sends, &send) - } - } - - // now query the pending nonces that we know are pending - for i := p.NonceLow; i < p.NonceHigh; i++ { - ntc, found := k.GetNonceToCctx(ctx, tss.TssPubkey, req.ChainId, i) - if !found { - return nil, status.Error(codes.Internal, "nonceToCctx not found") - } - cctx, found := k.GetCrossChainTx(ctx, ntc.CctxIndex) - if !found { - return nil, status.Error(codes.Internal, "cctxIndex not found") - } - sends = append(sends, &cctx) - } - - return &types.QueryAllCctxPendingResponse{CrossChainTx: sends}, nil -} - func (k Keeper) CreateNewCCTX(ctx sdk.Context, msg *types.MsgVoteOnObservedInboundTx, index string, tssPubkey string, s types.CctxStatus, senderChain, receiverChain *common.Chain) types.CrossChainTx { if msg.TxOrigin == "" { msg.TxOrigin = msg.Sender diff --git a/x/crosschain/keeper/migrator.go b/x/crosschain/keeper/migrator.go index c62d423249..c80e576bfe 100644 --- a/x/crosschain/keeper/migrator.go +++ b/x/crosschain/keeper/migrator.go @@ -4,6 +4,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" v2 "github.com/zeta-chain/zetacore/x/crosschain/migrations/v2" v3 "github.com/zeta-chain/zetacore/x/crosschain/migrations/v3" + v4 "github.com/zeta-chain/zetacore/x/crosschain/migrations/v4" ) // Migrator is a struct for handling in-place store migrations. @@ -18,11 +19,17 @@ func NewMigrator(keeper Keeper) Migrator { } } -// Migrate2to3 migrates the store from consensus version 2 to 3 +// Migrate1to2 migrates the store from consensus version 1 to 2 func (m Migrator) Migrate1to2(ctx sdk.Context) error { return v2.MigrateStore(ctx, m.crossChainKeeper.zetaObserverKeeper, m.crossChainKeeper.storeKey, m.crossChainKeeper.cdc) } +// Migrate2to3 migrates the store from consensus version 2 to 3 func (m Migrator) Migrate2to3(ctx sdk.Context) error { return v3.MigrateStore(ctx, m.crossChainKeeper.storeKey, m.crossChainKeeper.cdc) } + +// Migrate3to4 migrates the store from consensus version 3 to 4 +func (m Migrator) Migrate3to4(ctx sdk.Context) error { + return v4.MigrateStore(ctx, m.crossChainKeeper.storeKey, m.crossChainKeeper.cdc) +} diff --git a/x/crosschain/keeper/zeta_accounting.go b/x/crosschain/keeper/zeta_accounting.go new file mode 100644 index 0000000000..e69c881bf2 --- /dev/null +++ b/x/crosschain/keeper/zeta_accounting.go @@ -0,0 +1,59 @@ +package keeper + +import ( + sdkmath "cosmossdk.io/math" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/zeta-chain/zetacore/x/crosschain/types" +) + +func (k Keeper) SetZetaAccounting(ctx sdk.Context, abortedZetaAmount types.ZetaAccounting) { + store := ctx.KVStore(k.storeKey) + b := k.cdc.MustMarshal(&abortedZetaAmount) + store.Set([]byte(types.ZetaAccountingKey), b) +} + +func (k Keeper) GetZetaAccounting(ctx sdk.Context) (val types.ZetaAccounting, found bool) { + store := ctx.KVStore(k.storeKey) + b := store.Get([]byte(types.ZetaAccountingKey)) + if b == nil { + return val, false + } + k.cdc.MustUnmarshal(b, &val) + return val, true +} + +func (k Keeper) AddZetaAbortedAmount(ctx sdk.Context, amount sdkmath.Uint) { + zetaAccounting, found := k.GetZetaAccounting(ctx) + if !found { + zetaAccounting = types.ZetaAccounting{ + AbortedZetaAmount: amount, + } + } else { + zetaAccounting.AbortedZetaAmount = zetaAccounting.AbortedZetaAmount.Add(amount) + } + k.SetZetaAccounting(ctx, zetaAccounting) +} + +func (k Keeper) AddGasAbortedAmount(ctx sdk.Context, amount sdkmath.Uint) { + zetaAccounting, found := k.GetZetaAccounting(ctx) + if !found { + zetaAccounting = types.ZetaAccounting{ + AbortedGasAmount: amount, + } + } else { + zetaAccounting.AbortedGasAmount = zetaAccounting.AbortedGasAmount.Add(amount) + } + k.SetZetaAccounting(ctx, zetaAccounting) +} + +func (k Keeper) AddErc20AbortedAmount(ctx sdk.Context, amount sdkmath.Uint) { + zetaAccounting, found := k.GetZetaAccounting(ctx) + if !found { + zetaAccounting = types.ZetaAccounting{ + AbortedErc20Amount: amount, + } + } else { + zetaAccounting.AbortedErc20Amount = zetaAccounting.AbortedErc20Amount.Add(amount) + } + k.SetZetaAccounting(ctx, zetaAccounting) +} diff --git a/x/crosschain/keeper/zeta_accounting_test.go b/x/crosschain/keeper/zeta_accounting_test.go new file mode 100644 index 0000000000..f15451de2e --- /dev/null +++ b/x/crosschain/keeper/zeta_accounting_test.go @@ -0,0 +1,70 @@ +package keeper_test + +import ( + "math/rand" + "testing" + + sdkmath "cosmossdk.io/math" + "github.com/stretchr/testify/require" + keepertest "github.com/zeta-chain/zetacore/testutil/keeper" + "github.com/zeta-chain/zetacore/x/crosschain/types" +) + +func TestKeeper_AddZetaAccounting(t *testing.T) { + + t.Run("should add aborted zeta amount", func(t *testing.T) { + k, ctx, _, _ := keepertest.CrosschainKeeper(t) + originalAmount := sdkmath.NewUint(rand.Uint64()) + k.SetZetaAccounting(ctx, types.ZetaAccounting{ + AbortedZetaAmount: originalAmount, + }) + val, found := k.GetZetaAccounting(ctx) + require.True(t, found) + require.Equal(t, originalAmount, val.AbortedZetaAmount) + addAmount := sdkmath.NewUint(rand.Uint64()) + k.AddZetaAbortedAmount(ctx, addAmount) + val, found = k.GetZetaAccounting(ctx) + require.True(t, found) + require.Equal(t, originalAmount.Add(addAmount), val.AbortedZetaAmount) + }) + + t.Run("cant find aborted amount", func(t *testing.T) { + k, ctx, _, _ := keepertest.CrosschainKeeper(t) + val, found := k.GetZetaAccounting(ctx) + require.False(t, found) + require.Equal(t, types.ZetaAccounting{}, val) + }) + + t.Run("add very high zeta amount", func(t *testing.T) { + k, ctx, _, _ := keepertest.CrosschainKeeper(t) + highAmount := sdkmath.NewUintFromString("100000000000000000000000000000000000000000000000") + k.SetZetaAccounting(ctx, types.ZetaAccounting{ + AbortedZetaAmount: highAmount, + }) + val, found := k.GetZetaAccounting(ctx) + require.True(t, found) + require.Equal(t, highAmount, val.AbortedZetaAmount) + }) + t.Run("should add aborted gas and erc20 amounts", func(t *testing.T) { + k, ctx, _, _ := keepertest.CrosschainKeeper(t) + originalAmount := sdkmath.NewUint(rand.Uint64()) + k.SetZetaAccounting(ctx, types.ZetaAccounting{ + AbortedZetaAmount: originalAmount, + AbortedGasAmount: originalAmount, + AbortedErc20Amount: originalAmount, + }) + val, found := k.GetZetaAccounting(ctx) + require.True(t, found) + require.Equal(t, originalAmount, val.AbortedZetaAmount) + addAmount := sdkmath.NewUint(rand.Uint64()) + k.AddZetaAbortedAmount(ctx, addAmount) + k.AddErc20AbortedAmount(ctx, addAmount) + k.AddGasAbortedAmount(ctx, addAmount) + val, found = k.GetZetaAccounting(ctx) + require.True(t, found) + require.Equal(t, originalAmount.Add(addAmount), val.AbortedZetaAmount) + require.Equal(t, originalAmount.Add(addAmount), val.AbortedErc20Amount) + require.Equal(t, originalAmount.Add(addAmount), val.AbortedGasAmount) + }) + +} diff --git a/x/crosschain/migrations/v4/migrate.go b/x/crosschain/migrations/v4/migrate.go new file mode 100644 index 0000000000..adf2271ed7 --- /dev/null +++ b/x/crosschain/migrations/v4/migrate.go @@ -0,0 +1,42 @@ +package v4 + +import ( + "fmt" + + sdkmath "cosmossdk.io/math" + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/store/prefix" + storetypes "github.com/cosmos/cosmos-sdk/store/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/zeta-chain/zetacore/x/crosschain/types" +) + +// MigrateStore migrates the x/crosschain module state from the consensus version 3 to 4 +// It initializes the aborted zeta amount to 0 +func MigrateStore( + ctx sdk.Context, + crossChainStoreKey storetypes.StoreKey, + cdc codec.BinaryCodec, +) error { + p := types.KeyPrefix(fmt.Sprintf("%s", types.SendKey)) + prefixedStore := prefix.NewStore(ctx.KVStore(crossChainStoreKey), p) + abortedAmount := sdkmath.ZeroUint() + iterator := sdk.KVStorePrefixIterator(prefixedStore, []byte{}) + defer func(iterator sdk.Iterator) { + err := iterator.Close() + if err != nil { + panic(err) + } + }(iterator) + for ; iterator.Valid(); iterator.Next() { + var val types.CrossChainTx + cdc.MustUnmarshal(iterator.Value(), &val) + if val.CctxStatus.Status == types.CctxStatus_Aborted { + abortedAmount = abortedAmount.Add(val.GetCurrentOutTxParam().Amount) + } + } + b := cdc.MustMarshal(&types.ZetaAccounting{AbortedZetaAmount: abortedAmount}) + store := ctx.KVStore(crossChainStoreKey) + store.Set([]byte(types.ZetaAccountingKey), b) + return nil +} diff --git a/x/crosschain/migrations/v4/migrate_test.go b/x/crosschain/migrations/v4/migrate_test.go new file mode 100644 index 0000000000..057afda47e --- /dev/null +++ b/x/crosschain/migrations/v4/migrate_test.go @@ -0,0 +1,42 @@ +package v4_test + +import ( + "fmt" + "math/rand" + "testing" + + sdkmath "cosmossdk.io/math" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/assert" + keepertest "github.com/zeta-chain/zetacore/testutil/keeper" + "github.com/zeta-chain/zetacore/x/crosschain/keeper" + v4 "github.com/zeta-chain/zetacore/x/crosschain/migrations/v4" + "github.com/zeta-chain/zetacore/x/crosschain/types" +) + +func TestMigrateStore(t *testing.T) { + k, ctx, _, _ := keepertest.CrosschainKeeper(t) + amount := SetCrossRandomTx(10, ctx, *k) + err := v4.MigrateStore(ctx, k.GetStoreKey(), k.GetCodec()) + assert.NoError(t, err) + abortedZetaAmount, found := k.GetZetaAccounting(ctx) + assert.True(t, found) + assert.Equal(t, amount, abortedZetaAmount.AbortedZetaAmount) + +} + +func SetCrossRandomTx(maxlen int, ctx sdk.Context, k keeper.Keeper) sdkmath.Uint { + total := sdkmath.ZeroUint() + + r := rand.New(rand.NewSource(9)) + for i := 0; i < r.Intn(maxlen); i++ { + amount := sdkmath.NewUint(uint64(r.Uint32())) + k.SetCrossChainTx(ctx, types.CrossChainTx{ + Index: fmt.Sprintf("%d", i), + CctxStatus: &types.Status{Status: types.CctxStatus_Aborted}, + OutboundTxParams: []*types.OutboundTxParams{{Amount: amount}}, + }) + total = total.Add(amount) + } + return total +} diff --git a/x/crosschain/module.go b/x/crosschain/module.go index 4be40efde9..c4c8f70fac 100644 --- a/x/crosschain/module.go +++ b/x/crosschain/module.go @@ -154,6 +154,9 @@ func (am AppModule) RegisterServices(cfg module.Configurator) { if err := cfg.RegisterMigration(types.ModuleName, 2, m.Migrate2to3); err != nil { panic(err) } + if err := cfg.RegisterMigration(types.ModuleName, 3, m.Migrate3to4); err != nil { + panic(err) + } } // RegisterInvariants registers the crosschain module's invariants. @@ -181,7 +184,7 @@ func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.Raw } // ConsensusVersion implements AppModule/ConsensusVersion. -func (AppModule) ConsensusVersion() uint64 { return 3 } +func (AppModule) ConsensusVersion() uint64 { return 4 } // BeginBlock executes all ABCI BeginBlock logic respective to the crosschain module. func (am AppModule) BeginBlock(ctx sdk.Context, _ abci.RequestBeginBlock) { diff --git a/x/crosschain/types/cross_chain_tx.pb.go b/x/crosschain/types/cross_chain_tx.pb.go index 1b09cbe090..f7b48830b2 100644 --- a/x/crosschain/types/cross_chain_tx.pb.go +++ b/x/crosschain/types/cross_chain_tx.pb.go @@ -172,6 +172,45 @@ func (m *InboundTxParams) GetInboundTxFinalizedZetaHeight() uint64 { return 0 } +type ZetaAccounting struct { + AbortedZetaAmount github_com_cosmos_cosmos_sdk_types.Uint `protobuf:"bytes,1,opt,name=aborted_zeta_amount,json=abortedZetaAmount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Uint" json:"aborted_zeta_amount"` + AbortedGasAmount github_com_cosmos_cosmos_sdk_types.Uint `protobuf:"bytes,2,opt,name=aborted_gas_amount,json=abortedGasAmount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Uint" json:"aborted_gas_amount"` + AbortedErc20Amount github_com_cosmos_cosmos_sdk_types.Uint `protobuf:"bytes,3,opt,name=aborted_erc20_amount,json=abortedErc20Amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Uint" json:"aborted_erc20_amount"` +} + +func (m *ZetaAccounting) Reset() { *m = ZetaAccounting{} } +func (m *ZetaAccounting) String() string { return proto.CompactTextString(m) } +func (*ZetaAccounting) ProtoMessage() {} +func (*ZetaAccounting) Descriptor() ([]byte, []int) { + return fileDescriptor_af3a0ad055343c21, []int{1} +} +func (m *ZetaAccounting) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ZetaAccounting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ZetaAccounting.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 *ZetaAccounting) XXX_Merge(src proto.Message) { + xxx_messageInfo_ZetaAccounting.Merge(m, src) +} +func (m *ZetaAccounting) XXX_Size() int { + return m.Size() +} +func (m *ZetaAccounting) XXX_DiscardUnknown() { + xxx_messageInfo_ZetaAccounting.DiscardUnknown(m) +} + +var xxx_messageInfo_ZetaAccounting proto.InternalMessageInfo + type OutboundTxParams struct { Receiver string `protobuf:"bytes,1,opt,name=receiver,proto3" json:"receiver,omitempty"` ReceiverChainId int64 `protobuf:"varint,2,opt,name=receiver_chainId,json=receiverChainId,proto3" json:"receiver_chainId,omitempty"` @@ -195,7 +234,7 @@ func (m *OutboundTxParams) Reset() { *m = OutboundTxParams{} } func (m *OutboundTxParams) String() string { return proto.CompactTextString(m) } func (*OutboundTxParams) ProtoMessage() {} func (*OutboundTxParams) Descriptor() ([]byte, []int) { - return fileDescriptor_af3a0ad055343c21, []int{1} + return fileDescriptor_af3a0ad055343c21, []int{2} } func (m *OutboundTxParams) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -318,7 +357,7 @@ func (m *Status) Reset() { *m = Status{} } func (m *Status) String() string { return proto.CompactTextString(m) } func (*Status) ProtoMessage() {} func (*Status) Descriptor() ([]byte, []int) { - return fileDescriptor_af3a0ad055343c21, []int{2} + return fileDescriptor_af3a0ad055343c21, []int{3} } func (m *Status) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -382,7 +421,7 @@ func (m *CrossChainTx) Reset() { *m = CrossChainTx{} } func (m *CrossChainTx) String() string { return proto.CompactTextString(m) } func (*CrossChainTx) ProtoMessage() {} func (*CrossChainTx) Descriptor() ([]byte, []int) { - return fileDescriptor_af3a0ad055343c21, []int{3} + return fileDescriptor_af3a0ad055343c21, []int{4} } func (m *CrossChainTx) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -456,6 +495,7 @@ func (m *CrossChainTx) GetOutboundTxParams() []*OutboundTxParams { func init() { proto.RegisterEnum("zetachain.zetacore.crosschain.CctxStatus", CctxStatus_name, CctxStatus_value) proto.RegisterType((*InboundTxParams)(nil), "zetachain.zetacore.crosschain.InboundTxParams") + proto.RegisterType((*ZetaAccounting)(nil), "zetachain.zetacore.crosschain.ZetaAccounting") proto.RegisterType((*OutboundTxParams)(nil), "zetachain.zetacore.crosschain.OutboundTxParams") proto.RegisterType((*Status)(nil), "zetachain.zetacore.crosschain.Status") proto.RegisterType((*CrossChainTx)(nil), "zetachain.zetacore.crosschain.CrossChainTx") @@ -464,70 +504,75 @@ func init() { func init() { proto.RegisterFile("crosschain/cross_chain_tx.proto", fileDescriptor_af3a0ad055343c21) } var fileDescriptor_af3a0ad055343c21 = []byte{ - // 1003 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xdd, 0x4e, 0x1b, 0xc7, - 0x17, 0x67, 0xff, 0x36, 0xc6, 0x3e, 0x0e, 0x78, 0x19, 0x4c, 0xfe, 0x2b, 0xd2, 0xd8, 0x96, 0xdb, - 0x24, 0x4e, 0x25, 0x6c, 0x41, 0x55, 0x45, 0xea, 0x5d, 0xa0, 0x21, 0x41, 0x4d, 0x02, 0xda, 0xc2, - 0x0d, 0x52, 0xb5, 0x1d, 0xef, 0x1e, 0xec, 0x51, 0xec, 0x1d, 0x6b, 0x67, 0x8c, 0x96, 0xa8, 0x57, - 0x7d, 0x82, 0x3e, 0x44, 0x2b, 0xb5, 0x6f, 0x92, 0x8b, 0x5e, 0xe4, 0xb2, 0xea, 0x05, 0xaa, 0xe0, - 0x0d, 0xfa, 0x04, 0xd5, 0xcc, 0xec, 0xda, 0x6b, 0x17, 0x42, 0xab, 0x5e, 0xf9, 0x7c, 0xcc, 0xef, - 0xcc, 0xf9, 0xf8, 0x9d, 0xf1, 0x42, 0xdd, 0x8f, 0xb8, 0x10, 0x7e, 0x9f, 0xb2, 0xb0, 0xa3, 0x45, - 0x4f, 0xcb, 0x9e, 0x8c, 0xdb, 0xa3, 0x88, 0x4b, 0x4e, 0xee, 0xbf, 0x45, 0x49, 0xb5, 0xad, 0xad, - 0x25, 0x1e, 0x61, 0x7b, 0x8a, 0xd9, 0x58, 0xf3, 0xf9, 0x70, 0xc8, 0xc3, 0x8e, 0xf9, 0x31, 0x98, - 0x8d, 0x6a, 0x8f, 0xf7, 0xb8, 0x16, 0x3b, 0x4a, 0x32, 0xd6, 0xe6, 0xf7, 0x79, 0xa8, 0xec, 0x87, - 0x5d, 0x3e, 0x0e, 0x83, 0xa3, 0xf8, 0x90, 0x46, 0x74, 0x28, 0xc8, 0x5d, 0x28, 0x08, 0x0c, 0x03, - 0x8c, 0x1c, 0xab, 0x61, 0xb5, 0x4a, 0x6e, 0xa2, 0x91, 0x87, 0x50, 0x31, 0x52, 0x92, 0x0e, 0x0b, - 0x9c, 0xff, 0x35, 0xac, 0x56, 0xce, 0x5d, 0x36, 0xe6, 0x5d, 0x65, 0xdd, 0x0f, 0xc8, 0x3d, 0x28, - 0xc9, 0xd8, 0xe3, 0x11, 0xeb, 0xb1, 0xd0, 0xc9, 0xe9, 0x10, 0x45, 0x19, 0x1f, 0x68, 0x9d, 0x6c, - 0x42, 0xc9, 0xe7, 0xaa, 0x96, 0xf3, 0x11, 0x3a, 0xf9, 0x86, 0xd5, 0x5a, 0xd9, 0xb6, 0xdb, 0x49, - 0xa2, 0xbb, 0x9c, 0x85, 0x47, 0xe7, 0x23, 0x74, 0x8b, 0x7e, 0x22, 0x91, 0x2a, 0x2c, 0x52, 0x21, - 0x50, 0x3a, 0x8b, 0x3a, 0x8e, 0x51, 0xc8, 0x73, 0x28, 0xd0, 0x21, 0x1f, 0x87, 0xd2, 0x29, 0x28, - 0xf3, 0x4e, 0xe7, 0xdd, 0x45, 0x7d, 0xe1, 0xf7, 0x8b, 0xfa, 0xa3, 0x1e, 0x93, 0xfd, 0x71, 0x57, - 0xc5, 0xeb, 0xf8, 0x5c, 0x0c, 0xb9, 0x48, 0x7e, 0x36, 0x45, 0xf0, 0xa6, 0xa3, 0xae, 0x14, 0xed, - 0x63, 0x16, 0x4a, 0x37, 0x81, 0x93, 0x27, 0xe0, 0x30, 0x53, 0xbd, 0xa7, 0x52, 0xee, 0x0a, 0x8c, - 0xce, 0x30, 0xf0, 0xfa, 0x54, 0xf4, 0x9d, 0x25, 0x7d, 0xe3, 0x3a, 0x4b, 0xbb, 0x73, 0x90, 0x78, - 0x5f, 0x50, 0xd1, 0x27, 0x2f, 0xe1, 0xe3, 0xeb, 0x80, 0x18, 0x4b, 0x8c, 0x42, 0x3a, 0xf0, 0xfa, - 0xc8, 0x7a, 0x7d, 0xe9, 0x14, 0x1b, 0x56, 0x2b, 0xef, 0xd6, 0xff, 0x16, 0xe3, 0x59, 0x72, 0xee, - 0x85, 0x3e, 0x46, 0x3e, 0x87, 0xff, 0x67, 0xa2, 0x75, 0xe9, 0x60, 0xc0, 0xa5, 0xc7, 0xc2, 0x00, - 0x63, 0xa7, 0xa4, 0xb3, 0xa8, 0x4e, 0x22, 0xec, 0x68, 0xe7, 0xbe, 0xf2, 0x91, 0x3d, 0x68, 0x64, - 0x60, 0xa7, 0x2c, 0xa4, 0x03, 0xf6, 0x16, 0x03, 0x4f, 0x71, 0x22, 0xcd, 0x00, 0x74, 0x06, 0x1f, - 0x4d, 0xf0, 0x7b, 0xe9, 0xa9, 0x13, 0x94, 0xd4, 0x5c, 0xdf, 0xfc, 0xa5, 0x00, 0xf6, 0xc1, 0x58, - 0xce, 0xb2, 0x60, 0x03, 0x8a, 0x11, 0xfa, 0xc8, 0xce, 0x26, 0x3c, 0x98, 0xe8, 0xe4, 0x31, 0xd8, - 0xa9, 0x6c, 0xb8, 0xb0, 0x9f, 0x52, 0xa1, 0x92, 0xda, 0x53, 0x32, 0xcc, 0xcc, 0x3b, 0x77, 0xeb, - 0xbc, 0xa7, 0x93, 0xcd, 0xff, 0xb7, 0xc9, 0x6e, 0xc1, 0x3a, 0x4f, 0x4a, 0x52, 0xcd, 0x91, 0x42, - 0x78, 0x21, 0x0f, 0x7d, 0xd4, 0x44, 0xca, 0xbb, 0x84, 0x4f, 0xea, 0x3d, 0x12, 0xe2, 0xb5, 0xf2, - 0xcc, 0x43, 0x7a, 0x54, 0x78, 0x03, 0x36, 0x64, 0x86, 0x64, 0x33, 0x90, 0xe7, 0x54, 0xbc, 0x54, - 0x9e, 0xeb, 0x20, 0xa3, 0x88, 0xf9, 0x98, 0x90, 0x67, 0x16, 0x72, 0xa8, 0x3c, 0xa4, 0x05, 0x76, - 0x16, 0xa2, 0xa9, 0x56, 0xd4, 0xa7, 0x57, 0xa6, 0xa7, 0x35, 0xc7, 0x9e, 0x80, 0x93, 0x3d, 0x79, - 0x0d, 0x2d, 0xd6, 0xa7, 0x88, 0x2c, 0x2f, 0x5e, 0xc3, 0x27, 0x59, 0xe0, 0x8d, 0xec, 0x34, 0xdc, - 0x68, 0x4c, 0x83, 0xdc, 0x40, 0xcf, 0x0e, 0x54, 0xe7, 0xab, 0x1c, 0x0b, 0x0c, 0x9c, 0xaa, 0xc6, - 0xaf, 0xce, 0x14, 0x79, 0x2c, 0x30, 0x20, 0x12, 0xea, 0x59, 0x00, 0x9e, 0x9e, 0xa2, 0x2f, 0xd9, - 0x19, 0x66, 0x1a, 0xb4, 0xae, 0xc7, 0xdb, 0x4e, 0xc6, 0xfb, 0xf0, 0x1f, 0x8c, 0x77, 0x3f, 0x94, - 0xee, 0xbd, 0xe9, 0x5d, 0xcf, 0xd2, 0xa0, 0x93, 0xce, 0x7e, 0xf9, 0xa1, 0x5b, 0xcd, 0x24, 0xef, - 0xea, 0x8c, 0x6f, 0x88, 0x62, 0x46, 0x7a, 0x1f, 0x40, 0x91, 0x65, 0x34, 0xee, 0xbe, 0xc1, 0x73, - 0xa7, 0xac, 0xfb, 0x5c, 0x92, 0x42, 0x1c, 0x6a, 0x43, 0xf3, 0x27, 0x0b, 0x0a, 0x5f, 0x4b, 0x2a, - 0xc7, 0x82, 0x3c, 0x85, 0x82, 0xd0, 0x92, 0xde, 0x8f, 0x95, 0xed, 0xc7, 0xed, 0x0f, 0x3e, 0xcb, - 0xed, 0x5d, 0x5f, 0xc6, 0x06, 0xea, 0x26, 0x40, 0xf2, 0x00, 0x56, 0x8c, 0xe4, 0x0d, 0x51, 0x08, - 0xda, 0x43, 0xbd, 0x46, 0x25, 0x77, 0xd9, 0x58, 0x5f, 0x19, 0x23, 0xd9, 0x82, 0xea, 0x80, 0x0a, - 0x79, 0x3c, 0x0a, 0xa8, 0x44, 0x4f, 0xb2, 0x21, 0x0a, 0x49, 0x87, 0x23, 0xbd, 0x4f, 0x39, 0x77, - 0x6d, 0xea, 0x3b, 0x4a, 0x5d, 0xcd, 0x5f, 0x73, 0x70, 0x67, 0x57, 0xdd, 0xad, 0x17, 0xf1, 0x28, - 0x26, 0x0e, 0x2c, 0xf9, 0x11, 0x52, 0xc9, 0xd3, 0x75, 0x4e, 0x55, 0xf5, 0xc6, 0x1a, 0x52, 0x99, - 0xbb, 0x8d, 0x42, 0xbe, 0x85, 0x92, 0x7e, 0x47, 0x4e, 0x11, 0x85, 0x79, 0x7d, 0x77, 0x76, 0xff, - 0xe5, 0x32, 0xfe, 0x79, 0x51, 0xb7, 0xcf, 0xe9, 0x70, 0xf0, 0x45, 0x73, 0x12, 0xa9, 0xe9, 0x16, - 0x95, 0xbc, 0x87, 0x28, 0xc8, 0x23, 0xa8, 0x44, 0x38, 0xa0, 0xe7, 0x18, 0x4c, 0xaa, 0x2f, 0x98, - 0x45, 0x48, 0xcc, 0x69, 0xf9, 0x7b, 0x50, 0xf6, 0x7d, 0x19, 0x7b, 0x49, 0xb7, 0xd5, 0xb6, 0x94, - 0xb7, 0x1f, 0xdc, 0xd2, 0xed, 0xa4, 0xd3, 0xe0, 0x4f, 0xba, 0x4e, 0x4e, 0x60, 0x35, 0xf3, 0x5e, - 0x8e, 0xf4, 0x3b, 0xa7, 0x37, 0xa9, 0xbc, 0xdd, 0xbe, 0x25, 0xda, 0xdc, 0x7f, 0xa4, 0x5b, 0x61, - 0x73, 0x7f, 0x9a, 0xdf, 0x00, 0xc9, 0x92, 0x2f, 0x09, 0x0e, 0x8d, 0x5c, 0xab, 0xbc, 0xdd, 0xb9, - 0x25, 0xf8, 0xfc, 0xdb, 0xeb, 0xda, 0x7c, 0xce, 0xf2, 0xe9, 0x77, 0x00, 0x53, 0xfa, 0x10, 0x02, - 0x2b, 0x87, 0x18, 0x06, 0x2c, 0xec, 0x25, 0x79, 0xd9, 0x0b, 0x64, 0x0d, 0x2a, 0x89, 0x2d, 0x0d, - 0x67, 0x5b, 0x64, 0x15, 0x96, 0x53, 0xed, 0x15, 0x0b, 0x31, 0xb0, 0x73, 0xca, 0x94, 0x9c, 0x73, - 0xf1, 0x0c, 0x23, 0x69, 0xe7, 0xc9, 0x1d, 0x28, 0x1a, 0x19, 0x03, 0x7b, 0x91, 0x94, 0x61, 0xe9, - 0x69, 0x97, 0x6b, 0xa5, 0xb0, 0x91, 0xff, 0xf9, 0xc7, 0x9a, 0xb5, 0xf3, 0xd5, 0xbb, 0xcb, 0x9a, - 0xf5, 0xfe, 0xb2, 0x66, 0xfd, 0x71, 0x59, 0xb3, 0x7e, 0xb8, 0xaa, 0x2d, 0xbc, 0xbf, 0xaa, 0x2d, - 0xfc, 0x76, 0x55, 0x5b, 0x38, 0xd9, 0xca, 0x50, 0x41, 0x95, 0xb6, 0x69, 0xbe, 0x5a, 0xd2, 0x2a, - 0x3b, 0x71, 0x27, 0xf3, 0x2d, 0xa3, 0x99, 0xd1, 0x2d, 0xe8, 0x2f, 0x8f, 0xcf, 0xfe, 0x0a, 0x00, - 0x00, 0xff, 0xff, 0x46, 0x27, 0x16, 0x29, 0xe6, 0x08, 0x00, 0x00, + // 1075 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x4f, 0x4f, 0x1b, 0xc7, + 0x1b, 0x66, 0xb1, 0x31, 0xf6, 0xeb, 0x60, 0x2f, 0x83, 0xc9, 0x6f, 0x45, 0x7e, 0xb1, 0x2d, 0xb7, + 0x49, 0x9c, 0x4a, 0xd8, 0xc5, 0x55, 0x15, 0xa9, 0x37, 0xa0, 0x40, 0x50, 0x93, 0x80, 0xb6, 0x70, + 0x41, 0x8a, 0xb6, 0xe3, 0xdd, 0xc1, 0x1e, 0xc5, 0xde, 0xb1, 0x76, 0xc6, 0xc8, 0x44, 0x3d, 0xf5, + 0x13, 0xf4, 0x43, 0xb4, 0x52, 0x7b, 0xee, 0x97, 0xc8, 0xa1, 0x87, 0x1c, 0xab, 0x1e, 0x50, 0x05, + 0xdf, 0xa0, 0x9f, 0xa0, 0x9a, 0x3f, 0x6b, 0xaf, 0x5d, 0x08, 0x2d, 0x3d, 0xed, 0x3b, 0xef, 0xcc, + 0xf3, 0xbc, 0x7f, 0x66, 0x9e, 0x9d, 0x81, 0x8a, 0x1f, 0x31, 0xce, 0xfd, 0x2e, 0xa6, 0x61, 0x53, + 0x99, 0x9e, 0xb2, 0x3d, 0x31, 0x6a, 0x0c, 0x22, 0x26, 0x18, 0x7a, 0xf8, 0x96, 0x08, 0xac, 0x7c, + 0x0d, 0x65, 0xb1, 0x88, 0x34, 0x26, 0x98, 0xb5, 0x15, 0x9f, 0xf5, 0xfb, 0x2c, 0x6c, 0xea, 0x8f, + 0xc6, 0xac, 0x95, 0x3a, 0xac, 0xc3, 0x94, 0xd9, 0x94, 0x96, 0xf6, 0xd6, 0xbe, 0x4b, 0x43, 0x71, + 0x3f, 0x6c, 0xb3, 0x61, 0x18, 0x1c, 0x8d, 0x0e, 0x71, 0x84, 0xfb, 0x1c, 0xdd, 0x87, 0x0c, 0x27, + 0x61, 0x40, 0x22, 0xc7, 0xaa, 0x5a, 0xf5, 0x9c, 0x6b, 0x46, 0xe8, 0x31, 0x14, 0xb5, 0x65, 0xd2, + 0xa1, 0x81, 0x33, 0x5f, 0xb5, 0xea, 0x29, 0x77, 0x49, 0xbb, 0xb7, 0xa5, 0x77, 0x3f, 0x40, 0x0f, + 0x20, 0x27, 0x46, 0x1e, 0x8b, 0x68, 0x87, 0x86, 0x4e, 0x4a, 0x51, 0x64, 0xc5, 0xe8, 0x40, 0x8d, + 0xd1, 0x3a, 0xe4, 0x7c, 0x26, 0x6b, 0x39, 0x1f, 0x10, 0x27, 0x5d, 0xb5, 0xea, 0x85, 0x96, 0xdd, + 0x30, 0x89, 0x6e, 0x33, 0x1a, 0x1e, 0x9d, 0x0f, 0x88, 0x9b, 0xf5, 0x8d, 0x85, 0x4a, 0xb0, 0x80, + 0x39, 0x27, 0xc2, 0x59, 0x50, 0x3c, 0x7a, 0x80, 0xf6, 0x20, 0x83, 0xfb, 0x6c, 0x18, 0x0a, 0x27, + 0x23, 0xdd, 0x5b, 0xcd, 0x77, 0x17, 0x95, 0xb9, 0xdf, 0x2f, 0x2a, 0x4f, 0x3a, 0x54, 0x74, 0x87, + 0x6d, 0xc9, 0xd7, 0xf4, 0x19, 0xef, 0x33, 0x6e, 0x3e, 0xeb, 0x3c, 0x78, 0xd3, 0x94, 0x21, 0x79, + 0xe3, 0x98, 0x86, 0xc2, 0x35, 0x70, 0xf4, 0x0c, 0x1c, 0xaa, 0xab, 0xf7, 0x64, 0xca, 0x6d, 0x4e, + 0xa2, 0x33, 0x12, 0x78, 0x5d, 0xcc, 0xbb, 0xce, 0xa2, 0x8a, 0xb8, 0x4a, 0xe3, 0xee, 0x1c, 0x98, + 0xd9, 0xe7, 0x98, 0x77, 0xd1, 0x0b, 0xf8, 0xe8, 0x3a, 0x20, 0x19, 0x09, 0x12, 0x85, 0xb8, 0xe7, + 0x75, 0x09, 0xed, 0x74, 0x85, 0x93, 0xad, 0x5a, 0xf5, 0xb4, 0x5b, 0xf9, 0x1b, 0xc7, 0x8e, 0x59, + 0xf7, 0x5c, 0x2d, 0x43, 0x9f, 0xc3, 0xff, 0x12, 0x6c, 0x6d, 0xdc, 0xeb, 0x31, 0xe1, 0xd1, 0x30, + 0x20, 0x23, 0x27, 0xa7, 0xb2, 0x28, 0x8d, 0x19, 0xb6, 0xd4, 0xe4, 0xbe, 0x9c, 0x43, 0xbb, 0x50, + 0x4d, 0xc0, 0x4e, 0x69, 0x88, 0x7b, 0xf4, 0x2d, 0x09, 0x3c, 0x79, 0x26, 0xe2, 0x0c, 0x40, 0x65, + 0xf0, 0xff, 0x31, 0x7e, 0x37, 0x5e, 0x75, 0x42, 0x04, 0xd6, 0xe1, 0x6b, 0xbf, 0xcc, 0x43, 0x41, + 0x0e, 0x37, 0x7d, 0x5f, 0x76, 0x85, 0x86, 0x1d, 0xe4, 0xc1, 0x0a, 0x6e, 0xb3, 0x48, 0xc4, 0x6c, + 0xa6, 0xdd, 0xd6, 0xdd, 0xda, 0xbd, 0x6c, 0xb8, 0x54, 0x10, 0xdd, 0xf9, 0xd7, 0x80, 0xe2, 0x00, + 0x1d, 0xcc, 0x63, 0xfe, 0xf9, 0xbb, 0xf1, 0xdb, 0x86, 0x6a, 0x0f, 0x73, 0x43, 0x8f, 0xa1, 0x14, + 0xd3, 0x93, 0xc8, 0x6f, 0x7d, 0x1a, 0x07, 0x48, 0xdd, 0x2d, 0x40, 0x9c, 0xeb, 0x8e, 0xe4, 0xd2, + 0x21, 0x6a, 0x3f, 0x67, 0xc0, 0x3e, 0x18, 0x8a, 0x69, 0xed, 0xac, 0x41, 0x36, 0x22, 0x3e, 0xa1, + 0x67, 0x63, 0xf5, 0x8c, 0xc7, 0xe8, 0x29, 0xd8, 0xb1, 0xad, 0x15, 0xb4, 0x1f, 0x0b, 0xa8, 0x18, + 0xfb, 0x63, 0x09, 0x4d, 0xa9, 0x24, 0x75, 0xab, 0x4a, 0x26, 0x7a, 0x48, 0xff, 0x37, 0x3d, 0x6c, + 0xc0, 0x2a, 0x33, 0x25, 0xc9, 0x23, 0x25, 0x38, 0xf7, 0x42, 0x16, 0xfa, 0x44, 0xc9, 0x2f, 0xed, + 0x22, 0x36, 0xae, 0xf7, 0x88, 0xf3, 0x57, 0x72, 0x66, 0x16, 0x22, 0x37, 0xb3, 0x47, 0xfb, 0x54, + 0x4b, 0x73, 0x0a, 0xb2, 0x87, 0xf9, 0x0b, 0x39, 0x73, 0x1d, 0x64, 0x10, 0x51, 0x9f, 0x18, 0xc9, + 0x4d, 0x43, 0x0e, 0xe5, 0x0c, 0xaa, 0x83, 0x9d, 0x84, 0x28, 0x81, 0x66, 0xd5, 0xea, 0xc2, 0x64, + 0xb5, 0x52, 0xe6, 0x33, 0x70, 0x92, 0x2b, 0xaf, 0x11, 0xd3, 0xea, 0x04, 0x91, 0x54, 0xd3, 0x2b, + 0xf8, 0x38, 0x09, 0xbc, 0x51, 0xd3, 0x5a, 0x51, 0xd5, 0x09, 0xc9, 0x0d, 0xa2, 0x6e, 0x42, 0x69, + 0xb6, 0xca, 0x21, 0x27, 0x81, 0x53, 0x52, 0xf8, 0xe5, 0xa9, 0x22, 0x8f, 0x39, 0x09, 0x90, 0x80, + 0x4a, 0x12, 0x40, 0x4e, 0x4f, 0x89, 0x2f, 0xe8, 0x19, 0x49, 0x34, 0x68, 0x55, 0x6d, 0x6f, 0xc3, + 0x6c, 0xef, 0xe3, 0x7f, 0xb0, 0xbd, 0xfb, 0xa1, 0x70, 0x1f, 0x4c, 0x62, 0xed, 0xc4, 0xa4, 0xe3, + 0xce, 0x7e, 0xf9, 0xa1, 0xa8, 0x7a, 0x27, 0xef, 0xab, 0x8c, 0x6f, 0x60, 0xd1, 0x5b, 0xfa, 0x10, + 0x40, 0x1e, 0x96, 0xc1, 0xb0, 0xfd, 0x86, 0x9c, 0x3b, 0x79, 0xd5, 0xe7, 0x9c, 0xe0, 0xfc, 0x50, + 0x39, 0x6a, 0x3f, 0x5a, 0x90, 0xf9, 0x5a, 0x60, 0x31, 0xe4, 0x68, 0x13, 0x32, 0x5c, 0x59, 0x4a, + 0x1f, 0x85, 0xd6, 0xd3, 0xc6, 0x07, 0x2f, 0xb3, 0xc6, 0xb6, 0x2f, 0x46, 0x1a, 0xea, 0x1a, 0x20, + 0x7a, 0x04, 0x05, 0x6d, 0x79, 0x7d, 0xc2, 0x39, 0xee, 0x10, 0xfd, 0xdf, 0x70, 0x97, 0xb4, 0xf7, + 0xa5, 0x76, 0xa2, 0x0d, 0x28, 0xf5, 0x30, 0x17, 0xc7, 0x83, 0x00, 0x0b, 0xe2, 0x09, 0xda, 0x27, + 0x5c, 0xe0, 0xfe, 0x40, 0xe9, 0x29, 0xe5, 0xae, 0x4c, 0xe6, 0x8e, 0xe2, 0xa9, 0xda, 0xaf, 0x29, + 0xb8, 0xb7, 0x2d, 0x63, 0x2b, 0x21, 0x1e, 0x8d, 0x90, 0x03, 0x8b, 0x7e, 0x44, 0xb0, 0x60, 0xb1, + 0x9c, 0xe3, 0xa1, 0xbc, 0x99, 0xf4, 0xa1, 0xd2, 0xb1, 0xf5, 0x00, 0x7d, 0x03, 0x39, 0xf5, 0xbf, + 0x3c, 0x25, 0x84, 0xeb, 0x3b, 0x6b, 0x6b, 0xfb, 0x5f, 0x8a, 0xf1, 0xcf, 0x8b, 0x8a, 0x7d, 0x8e, + 0xfb, 0xbd, 0x2f, 0x6a, 0x63, 0xa6, 0x9a, 0x9b, 0x95, 0xf6, 0x2e, 0x21, 0x1c, 0x3d, 0x81, 0x62, + 0x44, 0x7a, 0xf8, 0x9c, 0x04, 0xe3, 0xea, 0x33, 0x5a, 0x08, 0xc6, 0x1d, 0x97, 0xbf, 0x0b, 0x79, + 0xdf, 0x17, 0x23, 0xcf, 0x74, 0x5b, 0xaa, 0x25, 0xdf, 0x7a, 0x74, 0x4b, 0xb7, 0x4d, 0xa7, 0xc1, + 0x1f, 0x77, 0x1d, 0x9d, 0xc0, 0x72, 0xe2, 0x96, 0x19, 0xa8, 0xff, 0x9c, 0x52, 0x52, 0xbe, 0xd5, + 0xb8, 0x85, 0x6d, 0xe6, 0x65, 0xe1, 0x16, 0xe9, 0xcc, 0x53, 0xe3, 0x35, 0xa0, 0xe4, 0xe1, 0x33, + 0xe4, 0x50, 0x4d, 0xd5, 0xf3, 0xad, 0xe6, 0x2d, 0xe4, 0xb3, 0xff, 0x5e, 0xd7, 0x66, 0x33, 0x9e, + 0x4f, 0xbe, 0x05, 0x98, 0x1c, 0x1f, 0x84, 0xa0, 0x70, 0x48, 0xc2, 0x80, 0x86, 0x1d, 0x93, 0x97, + 0x3d, 0x87, 0x56, 0xa0, 0x68, 0x7c, 0x31, 0x9d, 0x6d, 0xa1, 0x65, 0x58, 0x8a, 0x47, 0x2f, 0x69, + 0x48, 0x02, 0x3b, 0x25, 0x5d, 0x66, 0x9d, 0x4b, 0xce, 0x48, 0x24, 0xec, 0x34, 0xba, 0x07, 0x59, + 0x6d, 0x93, 0xc0, 0x5e, 0x40, 0x79, 0x58, 0xdc, 0xd4, 0x77, 0x84, 0x9d, 0x59, 0x4b, 0xff, 0xf4, + 0x43, 0xd9, 0xda, 0xfa, 0xea, 0xdd, 0x65, 0xd9, 0x7a, 0x7f, 0x59, 0xb6, 0xfe, 0xb8, 0x2c, 0x5b, + 0xdf, 0x5f, 0x95, 0xe7, 0xde, 0x5f, 0x95, 0xe7, 0x7e, 0xbb, 0x2a, 0xcf, 0x9d, 0x6c, 0x24, 0x8e, + 0x82, 0x2c, 0x6d, 0x5d, 0xbf, 0xf5, 0xe2, 0x2a, 0x9b, 0xa3, 0x66, 0xe2, 0x05, 0xa8, 0x4e, 0x46, + 0x3b, 0xa3, 0xde, 0x6b, 0x9f, 0xfd, 0x15, 0x00, 0x00, 0xff, 0xff, 0x44, 0xdd, 0x88, 0x4f, 0x1c, + 0x0a, 0x00, 0x00, } func (m *InboundTxParams) Marshal() (dAtA []byte, err error) { @@ -618,6 +663,59 @@ func (m *InboundTxParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *ZetaAccounting) 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 *ZetaAccounting) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ZetaAccounting) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.AbortedErc20Amount.Size() + i -= size + if _, err := m.AbortedErc20Amount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintCrossChainTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size := m.AbortedGasAmount.Size() + i -= size + if _, err := m.AbortedGasAmount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintCrossChainTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size := m.AbortedZetaAmount.Size() + i -= size + if _, err := m.AbortedZetaAmount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintCrossChainTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func (m *OutboundTxParams) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -923,6 +1021,21 @@ func (m *InboundTxParams) Size() (n int) { return n } +func (m *ZetaAccounting) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.AbortedZetaAmount.Size() + n += 1 + l + sovCrossChainTx(uint64(l)) + l = m.AbortedGasAmount.Size() + n += 1 + l + sovCrossChainTx(uint64(l)) + l = m.AbortedErc20Amount.Size() + n += 1 + l + sovCrossChainTx(uint64(l)) + return n +} + func (m *OutboundTxParams) Size() (n int) { if m == nil { return 0 @@ -1359,6 +1472,158 @@ func (m *InboundTxParams) Unmarshal(dAtA []byte) error { } return nil } +func (m *ZetaAccounting) 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 ErrIntOverflowCrossChainTx + } + 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: ZetaAccounting: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ZetaAccounting: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AbortedZetaAmount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCrossChainTx + } + 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 ErrInvalidLengthCrossChainTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCrossChainTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.AbortedZetaAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AbortedGasAmount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCrossChainTx + } + 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 ErrInvalidLengthCrossChainTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCrossChainTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.AbortedGasAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AbortedErc20Amount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCrossChainTx + } + 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 ErrInvalidLengthCrossChainTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCrossChainTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.AbortedErc20Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCrossChainTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCrossChainTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *OutboundTxParams) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/x/crosschain/types/genesis.pb.go b/x/crosschain/types/genesis.pb.go index c1b357ebad..1a9ceeafe4 100644 --- a/x/crosschain/types/genesis.pb.go +++ b/x/crosschain/types/genesis.pb.go @@ -36,6 +36,7 @@ type GenesisState struct { InTxHashToCctxList []InTxHashToCctx `protobuf:"bytes,9,rep,name=inTxHashToCctxList,proto3" json:"inTxHashToCctxList"` TssHistory []TSS `protobuf:"bytes,10,rep,name=tss_history,json=tssHistory,proto3" json:"tss_history"` InTxTrackerList []InTxTracker `protobuf:"bytes,11,rep,name=in_tx_tracker_list,json=inTxTrackerList,proto3" json:"in_tx_tracker_list"` + ZetaAccounting ZetaAccounting `protobuf:"bytes,12,opt,name=zeta_accounting,json=zetaAccounting,proto3" json:"zeta_accounting"` } func (m *GenesisState) Reset() { *m = GenesisState{} } @@ -141,6 +142,13 @@ func (m *GenesisState) GetInTxTrackerList() []InTxTracker { return nil } +func (m *GenesisState) GetZetaAccounting() ZetaAccounting { + if m != nil { + return m.ZetaAccounting + } + return ZetaAccounting{} +} + func init() { proto.RegisterType((*GenesisState)(nil), "zetachain.zetacore.crosschain.GenesisState") } @@ -148,39 +156,41 @@ func init() { func init() { proto.RegisterFile("crosschain/genesis.proto", fileDescriptor_dd51403692d571f4) } var fileDescriptor_dd51403692d571f4 = []byte{ - // 512 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xd1, 0x6e, 0xd3, 0x30, - 0x14, 0x86, 0x1b, 0x36, 0x0a, 0xb8, 0x43, 0x43, 0x06, 0x89, 0xa8, 0xd2, 0xb2, 0xa9, 0x08, 0x31, - 0x81, 0x96, 0x88, 0xc1, 0x13, 0xb4, 0x17, 0xeb, 0xb4, 0x09, 0x46, 0x9a, 0x2b, 0xa4, 0xc9, 0xb8, - 0x96, 0x95, 0x44, 0xeb, 0xe2, 0x2a, 0xc7, 0x95, 0x32, 0x9e, 0x82, 0xc7, 0xda, 0x1d, 0xbb, 0xe4, - 0x0a, 0xa1, 0xf6, 0x45, 0x90, 0x4f, 0xb2, 0xcd, 0xa1, 0x15, 0xe9, 0x4d, 0x65, 0xe5, 0xfc, 0xff, - 0x77, 0xfe, 0xda, 0xe7, 0x10, 0x57, 0xe4, 0x0a, 0x40, 0x24, 0x3c, 0xcd, 0x82, 0x58, 0x66, 0x12, - 0x52, 0xf0, 0xa7, 0xb9, 0xd2, 0x8a, 0xee, 0x7c, 0x97, 0x9a, 0x63, 0xc1, 0xc7, 0x93, 0xca, 0xa5, - 0x7f, 0x2f, 0xee, 0xee, 0x58, 0x46, 0xfc, 0x65, 0x99, 0xca, 0x84, 0xac, 0xdc, 0xdd, 0x5d, 0xbb, - 0x6c, 0x8e, 0xac, 0x14, 0xe9, 0xa2, 0x12, 0x74, 0xed, 0xc6, 0x1c, 0xd8, 0x34, 0x4f, 0x85, 0xac, - 0x6a, 0xaf, 0xac, 0x1a, 0x7a, 0x58, 0xc2, 0x21, 0x61, 0x5a, 0x31, 0x21, 0xee, 0x00, 0xde, 0x92, - 0x48, 0xe7, 0x5c, 0x5c, 0xc8, 0xbc, 0xaa, 0xf7, 0xac, 0xfa, 0x84, 0x83, 0x66, 0xe3, 0x89, 0x12, - 0x17, 0x2c, 0x91, 0x69, 0x9c, 0xe8, 0x15, 0x29, 0xd5, 0x4c, 0x2f, 0x43, 0x5e, 0x5a, 0x82, 0x29, - 0xcf, 0xf9, 0xe5, 0xed, 0xff, 0x7b, 0x61, 0x15, 0x34, 0xdc, 0x7d, 0x8d, 0x55, 0xac, 0xf0, 0x18, - 0x98, 0x53, 0xf9, 0xb5, 0xf7, 0xb3, 0x4d, 0xb6, 0x8e, 0xca, 0xbb, 0x1d, 0x69, 0xae, 0x25, 0x1d, - 0x90, 0x76, 0x09, 0x73, 0x9d, 0x3d, 0x67, 0xbf, 0x73, 0xf8, 0xda, 0xff, 0xef, 0x5d, 0xfb, 0x67, - 0x28, 0xee, 0x6f, 0x5e, 0xff, 0xde, 0x6d, 0x85, 0x95, 0x95, 0x9e, 0x93, 0x67, 0x6a, 0xa6, 0xa3, - 0x22, 0x2a, 0x03, 0x9f, 0xa6, 0xa0, 0xdd, 0x07, 0x7b, 0x1b, 0xfb, 0x9d, 0xc3, 0x77, 0x0d, 0xb8, - 0xcf, 0x96, 0xad, 0x82, 0x2e, 0xa1, 0xe8, 0x47, 0xb2, 0xa1, 0x01, 0xdc, 0x4d, 0x0c, 0xd8, 0x6b, - 0x20, 0x46, 0xa3, 0x51, 0x68, 0xe4, 0xf4, 0x84, 0x6c, 0xc5, 0x1c, 0xce, 0xcc, 0x5b, 0x62, 0xa0, - 0x87, 0x18, 0xe8, 0x4d, 0x83, 0xfd, 0xa8, 0xb2, 0x84, 0x35, 0x33, 0x8d, 0xc8, 0x36, 0xd6, 0x3f, - 0xe1, 0x60, 0x21, 0xaf, 0x8d, 0xbc, 0xb7, 0x0d, 0xbc, 0xc1, 0xbd, 0x2b, 0xfc, 0x17, 0x41, 0xbf, - 0x90, 0xa7, 0x03, 0x23, 0x45, 0x51, 0x54, 0x80, 0xfb, 0x68, 0xad, 0x4b, 0xb3, 0x3d, 0x61, 0x9d, - 0x40, 0xbf, 0x91, 0xe7, 0x66, 0xc2, 0xfa, 0x66, 0xc0, 0x86, 0x38, 0x5f, 0x18, 0xf6, 0x31, 0x82, - 0xfd, 0x06, 0xf0, 0x69, 0xdd, 0x19, 0xae, 0x42, 0x51, 0x41, 0xa8, 0x69, 0x35, 0xe4, 0x90, 0x44, - 0x6a, 0x20, 0x74, 0x81, 0x0d, 0x9e, 0x60, 0x83, 0x83, 0x86, 0x06, 0xc7, 0x35, 0x63, 0xf5, 0xe0, - 0x2b, 0x70, 0xf4, 0x98, 0x74, 0x34, 0x00, 0x4b, 0x52, 0xd0, 0x2a, 0xbf, 0x72, 0x09, 0xd2, 0xd7, - 0x78, 0xfa, 0x0a, 0x49, 0x34, 0xc0, 0xb0, 0xf4, 0xd2, 0x73, 0x93, 0xd7, 0x5a, 0x27, 0x36, 0x31, - 0x79, 0x3b, 0x6b, 0xbd, 0x9e, 0xc9, 0x5b, 0x9f, 0xce, 0xed, 0x34, 0xab, 0x0d, 0x67, 0xff, 0xe4, - 0x7a, 0xee, 0x39, 0x37, 0x73, 0xcf, 0xf9, 0x33, 0xf7, 0x9c, 0x1f, 0x0b, 0xaf, 0x75, 0xb3, 0xf0, - 0x5a, 0xbf, 0x16, 0x5e, 0xeb, 0xeb, 0xfb, 0x38, 0xd5, 0xc9, 0x6c, 0xec, 0x0b, 0x75, 0x19, 0x18, - 0xf8, 0x41, 0xb9, 0xa2, 0xb7, 0x7d, 0x82, 0x22, 0xb0, 0x17, 0xf7, 0x6a, 0x2a, 0x61, 0xdc, 0xc6, - 0x2d, 0xfd, 0xf0, 0x37, 0x00, 0x00, 0xff, 0xff, 0xeb, 0x12, 0x5d, 0x65, 0x0b, 0x05, 0x00, 0x00, + // 544 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x94, 0xd1, 0x6e, 0xd3, 0x30, + 0x14, 0x86, 0x5b, 0x36, 0x36, 0x70, 0x0b, 0x45, 0x06, 0x89, 0xa8, 0xd2, 0xb2, 0xa9, 0x08, 0x31, + 0x81, 0x96, 0x8a, 0xc1, 0x0b, 0xb0, 0x5e, 0xac, 0xd3, 0x26, 0x18, 0x69, 0xae, 0x26, 0x26, 0xe3, + 0x5a, 0x56, 0x12, 0xad, 0x8b, 0xab, 0xf8, 0x54, 0xca, 0xf6, 0x14, 0xbc, 0x08, 0xef, 0xb1, 0xcb, + 0x5d, 0x72, 0x85, 0x50, 0xfb, 0x22, 0xc8, 0x27, 0x59, 0xe7, 0xd0, 0x8a, 0xf4, 0xa6, 0xb2, 0x7c, + 0xfe, 0xff, 0x3b, 0x7f, 0xed, 0x13, 0x13, 0x47, 0xa4, 0x4a, 0x6b, 0x11, 0xf1, 0x38, 0xe9, 0x86, + 0x32, 0x91, 0x3a, 0xd6, 0xde, 0x38, 0x55, 0xa0, 0xe8, 0xd6, 0xb5, 0x04, 0x8e, 0x05, 0x0f, 0x57, + 0x2a, 0x95, 0xde, 0xbd, 0xb8, 0xbd, 0x65, 0x19, 0xf1, 0x97, 0x25, 0x2a, 0x11, 0xb2, 0x70, 0xb7, + 0xb7, 0xed, 0xb2, 0x59, 0xb2, 0x5c, 0x04, 0x59, 0x21, 0x68, 0xdb, 0x8d, 0xb9, 0x66, 0xe3, 0x34, + 0x16, 0xb2, 0xa8, 0xbd, 0xb2, 0x6a, 0xe8, 0x61, 0x11, 0xd7, 0x11, 0x03, 0xc5, 0x84, 0x98, 0x03, + 0xdc, 0x05, 0x11, 0xa4, 0x5c, 0x5c, 0xc8, 0xb4, 0xa8, 0x77, 0xac, 0xfa, 0x88, 0x6b, 0x60, 0xc3, + 0x91, 0x12, 0x17, 0x2c, 0x92, 0x71, 0x18, 0xc1, 0x92, 0x94, 0x6a, 0x02, 0x8b, 0x90, 0x97, 0x96, + 0x60, 0xcc, 0x53, 0x7e, 0x79, 0xf7, 0xff, 0x5e, 0x58, 0x05, 0xd0, 0xf3, 0xdd, 0x50, 0x85, 0x0a, + 0x97, 0x5d, 0xb3, 0xca, 0x77, 0x3b, 0x3f, 0x37, 0x49, 0xf3, 0x30, 0x3f, 0xdb, 0x01, 0x70, 0x90, + 0xb4, 0x47, 0x36, 0x72, 0x98, 0x53, 0xdf, 0xa9, 0xef, 0x36, 0xf6, 0x5f, 0x7b, 0xff, 0x3d, 0x6b, + 0xef, 0x14, 0xc5, 0x07, 0xeb, 0x37, 0xbf, 0xb7, 0x6b, 0x7e, 0x61, 0xa5, 0xe7, 0xe4, 0x99, 0x9a, + 0x40, 0x90, 0x05, 0x79, 0xe0, 0x93, 0x58, 0x83, 0xf3, 0x60, 0x67, 0x6d, 0xb7, 0xb1, 0xff, 0xae, + 0x02, 0xf7, 0xc5, 0xb2, 0x15, 0xd0, 0x05, 0x14, 0xfd, 0x48, 0xd6, 0x40, 0x6b, 0x67, 0x1d, 0x03, + 0x76, 0x2a, 0x88, 0xc1, 0x60, 0xe0, 0x1b, 0x39, 0x3d, 0x26, 0xcd, 0x90, 0xeb, 0x53, 0x73, 0x97, + 0x18, 0xe8, 0x21, 0x06, 0x7a, 0x53, 0x61, 0x3f, 0x2c, 0x2c, 0x7e, 0xc9, 0x4c, 0x03, 0xd2, 0xc2, + 0xfa, 0x67, 0x1c, 0x2c, 0xe4, 0x6d, 0x20, 0xef, 0x6d, 0x05, 0xaf, 0x77, 0xef, 0xf2, 0xff, 0x45, + 0xd0, 0xaf, 0xe4, 0x49, 0xcf, 0x48, 0x51, 0x14, 0x64, 0xda, 0xd9, 0x5c, 0xe9, 0xd0, 0x6c, 0x8f, + 0x5f, 0x26, 0xd0, 0xef, 0xe4, 0xb9, 0x99, 0xb0, 0x03, 0x33, 0x60, 0x7d, 0x9c, 0x2f, 0x0c, 0xfb, + 0x08, 0xc1, 0x5e, 0x05, 0xf8, 0xa4, 0xec, 0xf4, 0x97, 0xa1, 0xa8, 0x20, 0xd4, 0xb4, 0xea, 0x73, + 0x1d, 0x05, 0xaa, 0x27, 0x20, 0xc3, 0x06, 0x8f, 0xb1, 0xc1, 0x5e, 0x45, 0x83, 0xa3, 0x92, 0xb1, + 0xb8, 0xf0, 0x25, 0x38, 0x7a, 0x44, 0x1a, 0xa0, 0x35, 0x8b, 0x62, 0x0d, 0x2a, 0xbd, 0x72, 0x08, + 0xd2, 0x57, 0xb8, 0xfa, 0x02, 0x49, 0x40, 0xeb, 0x7e, 0xee, 0xa5, 0xe7, 0x26, 0xaf, 0xf5, 0x39, + 0xb1, 0x91, 0xc9, 0xdb, 0x58, 0xe9, 0xf6, 0x4c, 0xde, 0xf2, 0x74, 0xb6, 0xe2, 0xa4, 0x3c, 0x9c, + 0xdf, 0x48, 0xcb, 0x38, 0x19, 0x17, 0x42, 0x4d, 0x12, 0x88, 0x93, 0xd0, 0x69, 0xe2, 0xa0, 0x56, + 0x9d, 0xc5, 0x99, 0x04, 0xfe, 0x69, 0x6e, 0x2a, 0xf0, 0x4f, 0xaf, 0xcb, 0xbb, 0xc7, 0x37, 0x53, + 0xb7, 0x7e, 0x3b, 0x75, 0xeb, 0x7f, 0xa6, 0x6e, 0xfd, 0xc7, 0xcc, 0xad, 0xdd, 0xce, 0xdc, 0xda, + 0xaf, 0x99, 0x5b, 0x3b, 0x7b, 0x1f, 0xc6, 0x10, 0x4d, 0x86, 0x9e, 0x50, 0x97, 0x5d, 0x63, 0xda, + 0xcb, 0x1f, 0x80, 0xbb, 0x4e, 0xdd, 0xac, 0x6b, 0x3f, 0x0b, 0x57, 0x63, 0xa9, 0x87, 0x1b, 0xf8, + 0x06, 0x7c, 0xf8, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x92, 0x65, 0x10, 0x94, 0x69, 0x05, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { @@ -203,6 +213,16 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + { + size, err := m.ZetaAccounting.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x62 if len(m.InTxTrackerList) > 0 { for iNdEx := len(m.InTxTrackerList) - 1; iNdEx >= 0; iNdEx-- { { @@ -411,6 +431,8 @@ func (m *GenesisState) Size() (n int) { n += 1 + l + sovGenesis(uint64(l)) } } + l = m.ZetaAccounting.Size() + n += 1 + l + sovGenesis(uint64(l)) return n } @@ -790,6 +812,39 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ZetaAccounting", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ZetaAccounting.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenesis(dAtA[iNdEx:]) diff --git a/x/crosschain/types/keys.go b/x/crosschain/types/keys.go index 5af95e2e3c..e5520a3fb8 100644 --- a/x/crosschain/types/keys.go +++ b/x/crosschain/types/keys.go @@ -36,20 +36,11 @@ func KeyPrefix(p string) []byte { } const ( - TxinKey = "Txin-value-" - TxinVoterKey = "TxinVoter-value-" - - TxoutKey = "Txout-value-" - TxoutCountKey = "Txout-count-" - TxoutConfirmationKey = "TxoutConfirmation-value-" - SendKey = "Send-value-" - VoteCounterKey = "VoteCounter-value-" - ReceiveKey = "Receive-value-" - LastBlockHeightKey = "LastBlockHeight-value-" - ChainNoncesKey = "ChainNonces-value-" - GasPriceKey = "GasPrice-value-" - - GasBalanceKey = "GasBalance-value-" + SendKey = "Send-value-" + LastBlockHeightKey = "LastBlockHeight-value-" + ChainNoncesKey = "ChainNonces-value-" + GasPriceKey = "GasPrice-value-" + TSSKey = "TSS-value-" TSSHistoryKey = "TSS-History-value-" @@ -58,6 +49,9 @@ const ( NonceToCctxKeyPrefix = "NonceToCctx-value-" PendingNoncesKeyPrefix = "PendingNonces-value-" + // #nosec G101: Potential hardcoded credentials (gosec) + // ZetaAccountingKey value is used as prefix for storing ZetaAccountingKey + ZetaAccountingKey = "ZetaAccounting-value-" ) // OutTxTrackerKey returns the store key to retrieve a OutTxTracker from the index fields diff --git a/x/crosschain/types/query.pb.go b/x/crosschain/types/query.pb.go index bac8d3450a..a429bda856 100644 --- a/x/crosschain/types/query.pb.go +++ b/x/crosschain/types/query.pb.go @@ -31,6 +31,102 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package +type QueryZetaAccountingRequest struct { +} + +func (m *QueryZetaAccountingRequest) Reset() { *m = QueryZetaAccountingRequest{} } +func (m *QueryZetaAccountingRequest) String() string { return proto.CompactTextString(m) } +func (*QueryZetaAccountingRequest) ProtoMessage() {} +func (*QueryZetaAccountingRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_65a992045e92a606, []int{0} +} +func (m *QueryZetaAccountingRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryZetaAccountingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryZetaAccountingRequest.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 *QueryZetaAccountingRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryZetaAccountingRequest.Merge(m, src) +} +func (m *QueryZetaAccountingRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryZetaAccountingRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryZetaAccountingRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryZetaAccountingRequest proto.InternalMessageInfo + +type QueryZetaAccountingResponse struct { + AbortedZetaAmount string `protobuf:"bytes,1,opt,name=aborted_zeta_amount,json=abortedZetaAmount,proto3" json:"aborted_zeta_amount,omitempty"` + AbortedGasAmount string `protobuf:"bytes,2,opt,name=aborted_gas_amount,json=abortedGasAmount,proto3" json:"aborted_gas_amount,omitempty"` + AbortedErc20Amount string `protobuf:"bytes,3,opt,name=aborted_erc20_amount,json=abortedErc20Amount,proto3" json:"aborted_erc20_amount,omitempty"` +} + +func (m *QueryZetaAccountingResponse) Reset() { *m = QueryZetaAccountingResponse{} } +func (m *QueryZetaAccountingResponse) String() string { return proto.CompactTextString(m) } +func (*QueryZetaAccountingResponse) ProtoMessage() {} +func (*QueryZetaAccountingResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_65a992045e92a606, []int{1} +} +func (m *QueryZetaAccountingResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryZetaAccountingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryZetaAccountingResponse.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 *QueryZetaAccountingResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryZetaAccountingResponse.Merge(m, src) +} +func (m *QueryZetaAccountingResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryZetaAccountingResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryZetaAccountingResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryZetaAccountingResponse proto.InternalMessageInfo + +func (m *QueryZetaAccountingResponse) GetAbortedZetaAmount() string { + if m != nil { + return m.AbortedZetaAmount + } + return "" +} + +func (m *QueryZetaAccountingResponse) GetAbortedGasAmount() string { + if m != nil { + return m.AbortedGasAmount + } + return "" +} + +func (m *QueryZetaAccountingResponse) GetAbortedErc20Amount() string { + if m != nil { + return m.AbortedErc20Amount + } + return "" +} + type QueryCctxByStatusRequest struct { Status CctxStatus `protobuf:"varint,1,opt,name=status,proto3,enum=zetachain.zetacore.crosschain.CctxStatus" json:"status,omitempty"` } @@ -39,7 +135,7 @@ func (m *QueryCctxByStatusRequest) Reset() { *m = QueryCctxByStatusReque func (m *QueryCctxByStatusRequest) String() string { return proto.CompactTextString(m) } func (*QueryCctxByStatusRequest) ProtoMessage() {} func (*QueryCctxByStatusRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{0} + return fileDescriptor_65a992045e92a606, []int{2} } func (m *QueryCctxByStatusRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -83,7 +179,7 @@ func (m *QueryCctxByStatusResponse) Reset() { *m = QueryCctxByStatusResp func (m *QueryCctxByStatusResponse) String() string { return proto.CompactTextString(m) } func (*QueryCctxByStatusResponse) ProtoMessage() {} func (*QueryCctxByStatusResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{1} + return fileDescriptor_65a992045e92a606, []int{3} } func (m *QueryCctxByStatusResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -126,7 +222,7 @@ func (m *QueryTssHistoryRequest) Reset() { *m = QueryTssHistoryRequest{} func (m *QueryTssHistoryRequest) String() string { return proto.CompactTextString(m) } func (*QueryTssHistoryRequest) ProtoMessage() {} func (*QueryTssHistoryRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{2} + return fileDescriptor_65a992045e92a606, []int{4} } func (m *QueryTssHistoryRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -163,7 +259,7 @@ func (m *QueryTssHistoryResponse) Reset() { *m = QueryTssHistoryResponse func (m *QueryTssHistoryResponse) String() string { return proto.CompactTextString(m) } func (*QueryTssHistoryResponse) ProtoMessage() {} func (*QueryTssHistoryResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{3} + return fileDescriptor_65a992045e92a606, []int{5} } func (m *QueryTssHistoryResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -207,7 +303,7 @@ func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } func (*QueryParamsRequest) ProtoMessage() {} func (*QueryParamsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{4} + return fileDescriptor_65a992045e92a606, []int{6} } func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -246,7 +342,7 @@ func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} } func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) } func (*QueryParamsResponse) ProtoMessage() {} func (*QueryParamsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{5} + return fileDescriptor_65a992045e92a606, []int{7} } func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -291,7 +387,7 @@ func (m *QueryGetOutTxTrackerRequest) Reset() { *m = QueryGetOutTxTracke func (m *QueryGetOutTxTrackerRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetOutTxTrackerRequest) ProtoMessage() {} func (*QueryGetOutTxTrackerRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{6} + return fileDescriptor_65a992045e92a606, []int{8} } func (m *QueryGetOutTxTrackerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -342,7 +438,7 @@ func (m *QueryGetOutTxTrackerResponse) Reset() { *m = QueryGetOutTxTrack func (m *QueryGetOutTxTrackerResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetOutTxTrackerResponse) ProtoMessage() {} func (*QueryGetOutTxTrackerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{7} + return fileDescriptor_65a992045e92a606, []int{9} } func (m *QueryGetOutTxTrackerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -386,7 +482,7 @@ func (m *QueryAllOutTxTrackerRequest) Reset() { *m = QueryAllOutTxTracke func (m *QueryAllOutTxTrackerRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllOutTxTrackerRequest) ProtoMessage() {} func (*QueryAllOutTxTrackerRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{8} + return fileDescriptor_65a992045e92a606, []int{10} } func (m *QueryAllOutTxTrackerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -431,7 +527,7 @@ func (m *QueryAllOutTxTrackerResponse) Reset() { *m = QueryAllOutTxTrack func (m *QueryAllOutTxTrackerResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllOutTxTrackerResponse) ProtoMessage() {} func (*QueryAllOutTxTrackerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{9} + return fileDescriptor_65a992045e92a606, []int{11} } func (m *QueryAllOutTxTrackerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -483,7 +579,7 @@ func (m *QueryAllOutTxTrackerByChainRequest) Reset() { *m = QueryAllOutT func (m *QueryAllOutTxTrackerByChainRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllOutTxTrackerByChainRequest) ProtoMessage() {} func (*QueryAllOutTxTrackerByChainRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{10} + return fileDescriptor_65a992045e92a606, []int{12} } func (m *QueryAllOutTxTrackerByChainRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -535,7 +631,7 @@ func (m *QueryAllOutTxTrackerByChainResponse) Reset() { *m = QueryAllOut func (m *QueryAllOutTxTrackerByChainResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllOutTxTrackerByChainResponse) ProtoMessage() {} func (*QueryAllOutTxTrackerByChainResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{11} + return fileDescriptor_65a992045e92a606, []int{13} } func (m *QueryAllOutTxTrackerByChainResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -587,7 +683,7 @@ func (m *QueryAllInTxTrackerByChainRequest) Reset() { *m = QueryAllInTxT func (m *QueryAllInTxTrackerByChainRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllInTxTrackerByChainRequest) ProtoMessage() {} func (*QueryAllInTxTrackerByChainRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{12} + return fileDescriptor_65a992045e92a606, []int{14} } func (m *QueryAllInTxTrackerByChainRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -639,7 +735,7 @@ func (m *QueryAllInTxTrackerByChainResponse) Reset() { *m = QueryAllInTx func (m *QueryAllInTxTrackerByChainResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllInTxTrackerByChainResponse) ProtoMessage() {} func (*QueryAllInTxTrackerByChainResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{13} + return fileDescriptor_65a992045e92a606, []int{15} } func (m *QueryAllInTxTrackerByChainResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -689,7 +785,7 @@ func (m *QueryAllInTxTrackersRequest) Reset() { *m = QueryAllInTxTracker func (m *QueryAllInTxTrackersRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllInTxTrackersRequest) ProtoMessage() {} func (*QueryAllInTxTrackersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{14} + return fileDescriptor_65a992045e92a606, []int{16} } func (m *QueryAllInTxTrackersRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -726,7 +822,7 @@ func (m *QueryAllInTxTrackersResponse) Reset() { *m = QueryAllInTxTracke func (m *QueryAllInTxTrackersResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllInTxTrackersResponse) ProtoMessage() {} func (*QueryAllInTxTrackersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{15} + return fileDescriptor_65a992045e92a606, []int{17} } func (m *QueryAllInTxTrackersResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -770,7 +866,7 @@ func (m *QueryGetInTxHashToCctxRequest) Reset() { *m = QueryGetInTxHashT func (m *QueryGetInTxHashToCctxRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetInTxHashToCctxRequest) ProtoMessage() {} func (*QueryGetInTxHashToCctxRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{16} + return fileDescriptor_65a992045e92a606, []int{18} } func (m *QueryGetInTxHashToCctxRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -814,7 +910,7 @@ func (m *QueryGetInTxHashToCctxResponse) Reset() { *m = QueryGetInTxHash func (m *QueryGetInTxHashToCctxResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetInTxHashToCctxResponse) ProtoMessage() {} func (*QueryGetInTxHashToCctxResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{17} + return fileDescriptor_65a992045e92a606, []int{19} } func (m *QueryGetInTxHashToCctxResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -858,7 +954,7 @@ func (m *QueryInTxHashToCctxDataRequest) Reset() { *m = QueryInTxHashToC func (m *QueryInTxHashToCctxDataRequest) String() string { return proto.CompactTextString(m) } func (*QueryInTxHashToCctxDataRequest) ProtoMessage() {} func (*QueryInTxHashToCctxDataRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{18} + return fileDescriptor_65a992045e92a606, []int{20} } func (m *QueryInTxHashToCctxDataRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -902,7 +998,7 @@ func (m *QueryInTxHashToCctxDataResponse) Reset() { *m = QueryInTxHashTo func (m *QueryInTxHashToCctxDataResponse) String() string { return proto.CompactTextString(m) } func (*QueryInTxHashToCctxDataResponse) ProtoMessage() {} func (*QueryInTxHashToCctxDataResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{19} + return fileDescriptor_65a992045e92a606, []int{21} } func (m *QueryInTxHashToCctxDataResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -946,7 +1042,7 @@ func (m *QueryAllInTxHashToCctxRequest) Reset() { *m = QueryAllInTxHashT func (m *QueryAllInTxHashToCctxRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllInTxHashToCctxRequest) ProtoMessage() {} func (*QueryAllInTxHashToCctxRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{20} + return fileDescriptor_65a992045e92a606, []int{22} } func (m *QueryAllInTxHashToCctxRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -991,7 +1087,7 @@ func (m *QueryAllInTxHashToCctxResponse) Reset() { *m = QueryAllInTxHash func (m *QueryAllInTxHashToCctxResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllInTxHashToCctxResponse) ProtoMessage() {} func (*QueryAllInTxHashToCctxResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{21} + return fileDescriptor_65a992045e92a606, []int{23} } func (m *QueryAllInTxHashToCctxResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1042,7 +1138,7 @@ func (m *QueryGetTssAddressRequest) Reset() { *m = QueryGetTssAddressReq func (m *QueryGetTssAddressRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetTssAddressRequest) ProtoMessage() {} func (*QueryGetTssAddressRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{22} + return fileDescriptor_65a992045e92a606, []int{24} } func (m *QueryGetTssAddressRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1087,7 +1183,7 @@ func (m *QueryGetTssAddressResponse) Reset() { *m = QueryGetTssAddressRe func (m *QueryGetTssAddressResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetTssAddressResponse) ProtoMessage() {} func (*QueryGetTssAddressResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{23} + return fileDescriptor_65a992045e92a606, []int{25} } func (m *QueryGetTssAddressResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1137,7 +1233,7 @@ func (m *QueryGetTSSRequest) Reset() { *m = QueryGetTSSRequest{} } func (m *QueryGetTSSRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetTSSRequest) ProtoMessage() {} func (*QueryGetTSSRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{24} + return fileDescriptor_65a992045e92a606, []int{26} } func (m *QueryGetTSSRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1174,7 +1270,7 @@ func (m *QueryGetTSSResponse) Reset() { *m = QueryGetTSSResponse{} } func (m *QueryGetTSSResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetTSSResponse) ProtoMessage() {} func (*QueryGetTSSResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{25} + return fileDescriptor_65a992045e92a606, []int{27} } func (m *QueryGetTSSResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1218,7 +1314,7 @@ func (m *QueryGetGasPriceRequest) Reset() { *m = QueryGetGasPriceRequest func (m *QueryGetGasPriceRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetGasPriceRequest) ProtoMessage() {} func (*QueryGetGasPriceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{26} + return fileDescriptor_65a992045e92a606, []int{28} } func (m *QueryGetGasPriceRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1262,7 +1358,7 @@ func (m *QueryGetGasPriceResponse) Reset() { *m = QueryGetGasPriceRespon func (m *QueryGetGasPriceResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetGasPriceResponse) ProtoMessage() {} func (*QueryGetGasPriceResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{27} + return fileDescriptor_65a992045e92a606, []int{29} } func (m *QueryGetGasPriceResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1306,7 +1402,7 @@ func (m *QueryAllGasPriceRequest) Reset() { *m = QueryAllGasPriceRequest func (m *QueryAllGasPriceRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllGasPriceRequest) ProtoMessage() {} func (*QueryAllGasPriceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{28} + return fileDescriptor_65a992045e92a606, []int{30} } func (m *QueryAllGasPriceRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1351,7 +1447,7 @@ func (m *QueryAllGasPriceResponse) Reset() { *m = QueryAllGasPriceRespon func (m *QueryAllGasPriceResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllGasPriceResponse) ProtoMessage() {} func (*QueryAllGasPriceResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{29} + return fileDescriptor_65a992045e92a606, []int{31} } func (m *QueryAllGasPriceResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1402,7 +1498,7 @@ func (m *QueryGetChainNoncesRequest) Reset() { *m = QueryGetChainNoncesR func (m *QueryGetChainNoncesRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetChainNoncesRequest) ProtoMessage() {} func (*QueryGetChainNoncesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{30} + return fileDescriptor_65a992045e92a606, []int{32} } func (m *QueryGetChainNoncesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1446,7 +1542,7 @@ func (m *QueryGetChainNoncesResponse) Reset() { *m = QueryGetChainNonces func (m *QueryGetChainNoncesResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetChainNoncesResponse) ProtoMessage() {} func (*QueryGetChainNoncesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{31} + return fileDescriptor_65a992045e92a606, []int{33} } func (m *QueryGetChainNoncesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1490,7 +1586,7 @@ func (m *QueryAllChainNoncesRequest) Reset() { *m = QueryAllChainNoncesR func (m *QueryAllChainNoncesRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllChainNoncesRequest) ProtoMessage() {} func (*QueryAllChainNoncesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{32} + return fileDescriptor_65a992045e92a606, []int{34} } func (m *QueryAllChainNoncesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1535,7 +1631,7 @@ func (m *QueryAllChainNoncesResponse) Reset() { *m = QueryAllChainNonces func (m *QueryAllChainNoncesResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllChainNoncesResponse) ProtoMessage() {} func (*QueryAllChainNoncesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{33} + return fileDescriptor_65a992045e92a606, []int{35} } func (m *QueryAllChainNoncesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1585,7 +1681,7 @@ func (m *QueryAllPendingNoncesRequest) Reset() { *m = QueryAllPendingNon func (m *QueryAllPendingNoncesRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllPendingNoncesRequest) ProtoMessage() {} func (*QueryAllPendingNoncesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{34} + return fileDescriptor_65a992045e92a606, []int{36} } func (m *QueryAllPendingNoncesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1622,7 +1718,7 @@ func (m *QueryAllPendingNoncesResponse) Reset() { *m = QueryAllPendingNo func (m *QueryAllPendingNoncesResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllPendingNoncesResponse) ProtoMessage() {} func (*QueryAllPendingNoncesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{35} + return fileDescriptor_65a992045e92a606, []int{37} } func (m *QueryAllPendingNoncesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1666,7 +1762,7 @@ func (m *QueryPendingNoncesByChainRequest) Reset() { *m = QueryPendingNo func (m *QueryPendingNoncesByChainRequest) String() string { return proto.CompactTextString(m) } func (*QueryPendingNoncesByChainRequest) ProtoMessage() {} func (*QueryPendingNoncesByChainRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{36} + return fileDescriptor_65a992045e92a606, []int{38} } func (m *QueryPendingNoncesByChainRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1710,7 +1806,7 @@ func (m *QueryPendingNoncesByChainResponse) Reset() { *m = QueryPendingN func (m *QueryPendingNoncesByChainResponse) String() string { return proto.CompactTextString(m) } func (*QueryPendingNoncesByChainResponse) ProtoMessage() {} func (*QueryPendingNoncesByChainResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{37} + return fileDescriptor_65a992045e92a606, []int{39} } func (m *QueryPendingNoncesByChainResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1754,7 +1850,7 @@ func (m *QueryGetLastBlockHeightRequest) Reset() { *m = QueryGetLastBloc func (m *QueryGetLastBlockHeightRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetLastBlockHeightRequest) ProtoMessage() {} func (*QueryGetLastBlockHeightRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{38} + return fileDescriptor_65a992045e92a606, []int{40} } func (m *QueryGetLastBlockHeightRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1798,7 +1894,7 @@ func (m *QueryGetLastBlockHeightResponse) Reset() { *m = QueryGetLastBlo func (m *QueryGetLastBlockHeightResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetLastBlockHeightResponse) ProtoMessage() {} func (*QueryGetLastBlockHeightResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{39} + return fileDescriptor_65a992045e92a606, []int{41} } func (m *QueryGetLastBlockHeightResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1842,7 +1938,7 @@ func (m *QueryAllLastBlockHeightRequest) Reset() { *m = QueryAllLastBloc func (m *QueryAllLastBlockHeightRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllLastBlockHeightRequest) ProtoMessage() {} func (*QueryAllLastBlockHeightRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{40} + return fileDescriptor_65a992045e92a606, []int{42} } func (m *QueryAllLastBlockHeightRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1887,7 +1983,7 @@ func (m *QueryAllLastBlockHeightResponse) Reset() { *m = QueryAllLastBlo func (m *QueryAllLastBlockHeightResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllLastBlockHeightResponse) ProtoMessage() {} func (*QueryAllLastBlockHeightResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{41} + return fileDescriptor_65a992045e92a606, []int{43} } func (m *QueryAllLastBlockHeightResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1938,7 +2034,7 @@ func (m *QueryGetCctxRequest) Reset() { *m = QueryGetCctxRequest{} } func (m *QueryGetCctxRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetCctxRequest) ProtoMessage() {} func (*QueryGetCctxRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{42} + return fileDescriptor_65a992045e92a606, []int{44} } func (m *QueryGetCctxRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1983,7 +2079,7 @@ func (m *QueryGetCctxByNonceRequest) Reset() { *m = QueryGetCctxByNonceR func (m *QueryGetCctxByNonceRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetCctxByNonceRequest) ProtoMessage() {} func (*QueryGetCctxByNonceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{43} + return fileDescriptor_65a992045e92a606, []int{45} } func (m *QueryGetCctxByNonceRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2034,7 +2130,7 @@ func (m *QueryGetCctxResponse) Reset() { *m = QueryGetCctxResponse{} } func (m *QueryGetCctxResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetCctxResponse) ProtoMessage() {} func (*QueryGetCctxResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{44} + return fileDescriptor_65a992045e92a606, []int{46} } func (m *QueryGetCctxResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2078,7 +2174,7 @@ func (m *QueryAllCctxRequest) Reset() { *m = QueryAllCctxRequest{} } func (m *QueryAllCctxRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllCctxRequest) ProtoMessage() {} func (*QueryAllCctxRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{45} + return fileDescriptor_65a992045e92a606, []int{47} } func (m *QueryAllCctxRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2123,7 +2219,7 @@ func (m *QueryAllCctxResponse) Reset() { *m = QueryAllCctxResponse{} } func (m *QueryAllCctxResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllCctxResponse) ProtoMessage() {} func (*QueryAllCctxResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{46} + return fileDescriptor_65a992045e92a606, []int{48} } func (m *QueryAllCctxResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2175,7 +2271,7 @@ func (m *QueryAllCctxPendingRequest) Reset() { *m = QueryAllCctxPendingR func (m *QueryAllCctxPendingRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllCctxPendingRequest) ProtoMessage() {} func (*QueryAllCctxPendingRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{47} + return fileDescriptor_65a992045e92a606, []int{49} } func (m *QueryAllCctxPendingRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2227,7 +2323,7 @@ func (m *QueryAllCctxPendingResponse) Reset() { *m = QueryAllCctxPending func (m *QueryAllCctxPendingResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllCctxPendingResponse) ProtoMessage() {} func (*QueryAllCctxPendingResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{48} + return fileDescriptor_65a992045e92a606, []int{50} } func (m *QueryAllCctxPendingResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2277,7 +2373,7 @@ func (m *QueryLastZetaHeightRequest) Reset() { *m = QueryLastZetaHeightR func (m *QueryLastZetaHeightRequest) String() string { return proto.CompactTextString(m) } func (*QueryLastZetaHeightRequest) ProtoMessage() {} func (*QueryLastZetaHeightRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{49} + return fileDescriptor_65a992045e92a606, []int{51} } func (m *QueryLastZetaHeightRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2314,7 +2410,7 @@ func (m *QueryLastZetaHeightResponse) Reset() { *m = QueryLastZetaHeight func (m *QueryLastZetaHeightResponse) String() string { return proto.CompactTextString(m) } func (*QueryLastZetaHeightResponse) ProtoMessage() {} func (*QueryLastZetaHeightResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{50} + return fileDescriptor_65a992045e92a606, []int{52} } func (m *QueryLastZetaHeightResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2359,7 +2455,7 @@ func (m *QueryConvertGasToZetaRequest) Reset() { *m = QueryConvertGasToZ func (m *QueryConvertGasToZetaRequest) String() string { return proto.CompactTextString(m) } func (*QueryConvertGasToZetaRequest) ProtoMessage() {} func (*QueryConvertGasToZetaRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{51} + return fileDescriptor_65a992045e92a606, []int{53} } func (m *QueryConvertGasToZetaRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2412,7 +2508,7 @@ func (m *QueryConvertGasToZetaResponse) Reset() { *m = QueryConvertGasTo func (m *QueryConvertGasToZetaResponse) String() string { return proto.CompactTextString(m) } func (*QueryConvertGasToZetaResponse) ProtoMessage() {} func (*QueryConvertGasToZetaResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{52} + return fileDescriptor_65a992045e92a606, []int{54} } func (m *QueryConvertGasToZetaResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2469,7 +2565,7 @@ func (m *QueryMessagePassingProtocolFeeRequest) Reset() { *m = QueryMess func (m *QueryMessagePassingProtocolFeeRequest) String() string { return proto.CompactTextString(m) } func (*QueryMessagePassingProtocolFeeRequest) ProtoMessage() {} func (*QueryMessagePassingProtocolFeeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{53} + return fileDescriptor_65a992045e92a606, []int{55} } func (m *QueryMessagePassingProtocolFeeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2508,7 +2604,7 @@ func (m *QueryMessagePassingProtocolFeeResponse) Reset() { func (m *QueryMessagePassingProtocolFeeResponse) String() string { return proto.CompactTextString(m) } func (*QueryMessagePassingProtocolFeeResponse) ProtoMessage() {} func (*QueryMessagePassingProtocolFeeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{54} + return fileDescriptor_65a992045e92a606, []int{56} } func (m *QueryMessagePassingProtocolFeeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2552,7 +2648,7 @@ func (m *QueryZEVMGetTransactionReceiptRequest) Reset() { *m = QueryZEVM func (m *QueryZEVMGetTransactionReceiptRequest) String() string { return proto.CompactTextString(m) } func (*QueryZEVMGetTransactionReceiptRequest) ProtoMessage() {} func (*QueryZEVMGetTransactionReceiptRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{55} + return fileDescriptor_65a992045e92a606, []int{57} } func (m *QueryZEVMGetTransactionReceiptRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2609,7 +2705,7 @@ func (m *QueryZEVMGetTransactionReceiptResponse) Reset() { func (m *QueryZEVMGetTransactionReceiptResponse) String() string { return proto.CompactTextString(m) } func (*QueryZEVMGetTransactionReceiptResponse) ProtoMessage() {} func (*QueryZEVMGetTransactionReceiptResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{56} + return fileDescriptor_65a992045e92a606, []int{58} } func (m *QueryZEVMGetTransactionReceiptResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2739,7 +2835,7 @@ func (m *Log) Reset() { *m = Log{} } func (m *Log) String() string { return proto.CompactTextString(m) } func (*Log) ProtoMessage() {} func (*Log) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{57} + return fileDescriptor_65a992045e92a606, []int{59} } func (m *Log) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2839,7 +2935,7 @@ func (m *QueryZEVMGetTransactionRequest) Reset() { *m = QueryZEVMGetTran func (m *QueryZEVMGetTransactionRequest) String() string { return proto.CompactTextString(m) } func (*QueryZEVMGetTransactionRequest) ProtoMessage() {} func (*QueryZEVMGetTransactionRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{58} + return fileDescriptor_65a992045e92a606, []int{60} } func (m *QueryZEVMGetTransactionRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2899,7 +2995,7 @@ func (m *QueryZEVMGetTransactionResponse) Reset() { *m = QueryZEVMGetTra func (m *QueryZEVMGetTransactionResponse) String() string { return proto.CompactTextString(m) } func (*QueryZEVMGetTransactionResponse) ProtoMessage() {} func (*QueryZEVMGetTransactionResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{59} + return fileDescriptor_65a992045e92a606, []int{61} } func (m *QueryZEVMGetTransactionResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3055,7 +3151,7 @@ func (m *QueryZEVMGetBlockByNumberRequest) Reset() { *m = QueryZEVMGetBl func (m *QueryZEVMGetBlockByNumberRequest) String() string { return proto.CompactTextString(m) } func (*QueryZEVMGetBlockByNumberRequest) ProtoMessage() {} func (*QueryZEVMGetBlockByNumberRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{60} + return fileDescriptor_65a992045e92a606, []int{62} } func (m *QueryZEVMGetBlockByNumberRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3119,7 +3215,7 @@ func (m *QueryZEVMGetBlockByNumberResponse) Reset() { *m = QueryZEVMGetB func (m *QueryZEVMGetBlockByNumberResponse) String() string { return proto.CompactTextString(m) } func (*QueryZEVMGetBlockByNumberResponse) ProtoMessage() {} func (*QueryZEVMGetBlockByNumberResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{61} + return fileDescriptor_65a992045e92a606, []int{63} } func (m *QueryZEVMGetBlockByNumberResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3296,6 +3392,8 @@ func (m *QueryZEVMGetBlockByNumberResponse) GetMixHash() string { } func init() { + proto.RegisterType((*QueryZetaAccountingRequest)(nil), "zetachain.zetacore.crosschain.QueryZetaAccountingRequest") + proto.RegisterType((*QueryZetaAccountingResponse)(nil), "zetachain.zetacore.crosschain.QueryZetaAccountingResponse") proto.RegisterType((*QueryCctxByStatusRequest)(nil), "zetachain.zetacore.crosschain.QueryCctxByStatusRequest") proto.RegisterType((*QueryCctxByStatusResponse)(nil), "zetachain.zetacore.crosschain.QueryCctxByStatusResponse") proto.RegisterType((*QueryTssHistoryRequest)(nil), "zetachain.zetacore.crosschain.QueryTssHistoryRequest") @@ -3363,210 +3461,216 @@ func init() { func init() { proto.RegisterFile("crosschain/query.proto", fileDescriptor_65a992045e92a606) } var fileDescriptor_65a992045e92a606 = []byte{ - // 3234 bytes of a gzipped FileDescriptorProto + // 3339 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5b, 0xdb, 0x6f, 0x1b, 0xc7, - 0xd5, 0xf7, 0x8a, 0xba, 0x0e, 0x75, 0xf3, 0x58, 0x71, 0x18, 0xc6, 0x16, 0x9d, 0x75, 0x7c, 0xb7, - 0xc9, 0x58, 0xb1, 0x95, 0xc4, 0x76, 0xf2, 0x45, 0xb2, 0x63, 0xc5, 0x88, 0x92, 0xe8, 0x5b, 0x29, - 0xdf, 0xd7, 0xba, 0x48, 0x89, 0x15, 0x39, 0xa6, 0x16, 0x26, 0xb9, 0xcc, 0xce, 0x50, 0x90, 0x62, - 0xa8, 0x2d, 0xf2, 0xd0, 0xe7, 0x00, 0x05, 0xda, 0x97, 0xbe, 0xf6, 0xf2, 0xd0, 0x87, 0x02, 0x0d, - 0x9a, 0x02, 0x05, 0x52, 0x14, 0x6d, 0xd3, 0x3c, 0x06, 0x2d, 0x50, 0xf4, 0x02, 0x10, 0x45, 0xd2, - 0x27, 0xfe, 0x07, 0x05, 0xfa, 0x50, 0xcc, 0xd9, 0xb3, 0xdc, 0x59, 0xee, 0xae, 0xb8, 0xa2, 0x98, - 0xa0, 0x7d, 0x11, 0x67, 0xce, 0xec, 0x39, 0xf3, 0x3b, 0x97, 0x39, 0x73, 0x66, 0x67, 0x45, 0x8e, - 0x97, 0x1c, 0x9b, 0xf3, 0xd2, 0x96, 0x69, 0xd5, 0x0b, 0xef, 0x34, 0x99, 0xb3, 0x9b, 0x6f, 0x38, - 0xb6, 0xb0, 0xe9, 0xc9, 0x77, 0x99, 0x30, 0x81, 0x9c, 0x87, 0x96, 0xed, 0xb0, 0xbc, 0xff, 0x68, - 0xf6, 0x62, 0xc9, 0xe6, 0x35, 0x9b, 0x17, 0x36, 0x4d, 0xce, 0x5c, 0xbe, 0xc2, 0xf6, 0xd5, 0x4d, - 0x26, 0xcc, 0xab, 0x85, 0x86, 0x59, 0xb1, 0xea, 0xa6, 0xb0, 0xec, 0xba, 0x2b, 0x2a, 0x7b, 0x52, - 0x99, 0x02, 0xfe, 0x16, 0xeb, 0x76, 0xbd, 0xc4, 0x38, 0x0e, 0xe7, 0xd4, 0x61, 0xd9, 0x2c, 0xba, - 0x0f, 0x89, 0x1d, 0x7c, 0x20, 0xab, 0x3c, 0x50, 0x31, 0x79, 0xb1, 0xe1, 0x58, 0x25, 0x86, 0x63, - 0xa7, 0x95, 0x31, 0xe0, 0x29, 0x6e, 0x99, 0x7c, 0xab, 0x28, 0xec, 0x62, 0xa9, 0xd4, 0x11, 0x30, - 0x1f, 0x7a, 0x48, 0x38, 0x66, 0xe9, 0x21, 0x73, 0x70, 0x5c, 0x57, 0xc6, 0xab, 0x26, 0x17, 0xc5, - 0xcd, 0xaa, 0x5d, 0x7a, 0x58, 0xdc, 0x62, 0x56, 0x65, 0x4b, 0x44, 0xc8, 0x00, 0xf8, 0x5d, 0x73, - 0xa8, 0x5a, 0xd8, 0x4d, 0x11, 0x9e, 0xe4, 0x71, 0xe5, 0x81, 0x86, 0xe9, 0x98, 0x35, 0x4f, 0xff, - 0x39, 0x65, 0x40, 0xf0, 0x0e, 0xb5, 0x62, 0x57, 0x6c, 0x68, 0x16, 0x64, 0x0b, 0xa9, 0x27, 0x2a, - 0xb6, 0x5d, 0xa9, 0xb2, 0x82, 0xd9, 0xb0, 0x0a, 0x66, 0xbd, 0x6e, 0x0b, 0xb0, 0x33, 0xf2, 0xe8, - 0x6f, 0x93, 0xcc, 0xff, 0x4a, 0x57, 0xdc, 0x2e, 0x89, 0x9d, 0xe5, 0xdd, 0x75, 0x61, 0x8a, 0x26, - 0x37, 0xd8, 0x3b, 0x4d, 0xc6, 0x05, 0x5d, 0x22, 0xa3, 0x1c, 0x08, 0x19, 0xed, 0x94, 0x76, 0x7e, - 0x7a, 0xe1, 0x42, 0x7e, 0x5f, 0x07, 0xe7, 0xa5, 0x0c, 0x94, 0x80, 0x8c, 0xba, 0x43, 0x9e, 0x88, - 0x10, 0xcf, 0x1b, 0x76, 0x9d, 0x33, 0xfa, 0x16, 0x99, 0xbc, 0x2d, 0xb9, 0x6f, 0x4b, 0xee, 0x8d, - 0x9d, 0x8c, 0x76, 0x2a, 0x75, 0x3e, 0xbd, 0x70, 0xa9, 0xd7, 0x2c, 0x0a, 0xcb, 0xf2, 0xf0, 0x27, - 0xad, 0xdc, 0x11, 0x23, 0x20, 0x46, 0xcf, 0x90, 0xe3, 0x30, 0xe7, 0x06, 0xe7, 0xaf, 0x5a, 0x5c, - 0xd8, 0xce, 0x2e, 0x2a, 0xa4, 0x7f, 0x9d, 0x3c, 0x1e, 0x1a, 0x41, 0x2c, 0xb7, 0xc9, 0xb8, 0xe0, - 0xbc, 0x58, 0xb5, 0xb8, 0x40, 0x1c, 0x7a, 0x0f, 0x1c, 0x1b, 0xeb, 0xeb, 0x38, 0xfd, 0x98, 0xe0, - 0x7c, 0xd5, 0xe2, 0x42, 0x9f, 0x23, 0x14, 0xe4, 0xaf, 0x81, 0xaf, 0xbc, 0x59, 0xef, 0x93, 0x63, - 0x01, 0x6a, 0x67, 0xc6, 0x51, 0xd7, 0xa7, 0x60, 0xdd, 0xf4, 0xc2, 0x99, 0x1e, 0xf3, 0xb9, 0xec, - 0x38, 0x25, 0xb2, 0xea, 0xaf, 0x93, 0x27, 0x41, 0xf6, 0x0a, 0x13, 0x6f, 0x36, 0xc5, 0xc6, 0xce, - 0x86, 0x1b, 0x3f, 0x9e, 0x07, 0x33, 0x64, 0x0c, 0x98, 0xef, 0xdd, 0x81, 0x49, 0x52, 0x86, 0xd7, - 0xa5, 0x73, 0x64, 0x04, 0x42, 0x32, 0x33, 0x74, 0x4a, 0x3b, 0x3f, 0x6c, 0xb8, 0x1d, 0xbd, 0x49, - 0x4e, 0x44, 0x8b, 0xf3, 0x3d, 0x66, 0x2b, 0x74, 0x44, 0xde, 0xcb, 0x63, 0xaa, 0x28, 0xcf, 0x63, - 0xaa, 0x18, 0x9d, 0xa1, 0x16, 0x4b, 0xd5, 0x6a, 0x94, 0x16, 0x77, 0x09, 0xf1, 0x13, 0x04, 0xce, - 0x79, 0x36, 0xef, 0x66, 0x93, 0xbc, 0xcc, 0x26, 0x79, 0x37, 0x0b, 0x61, 0x36, 0xc9, 0xaf, 0x99, - 0x15, 0x86, 0xbc, 0x86, 0xc2, 0xa9, 0x7f, 0xa4, 0xa1, 0x7a, 0xa1, 0x79, 0x62, 0xd5, 0x4b, 0x0d, - 0x40, 0x3d, 0xba, 0x12, 0xc0, 0x3f, 0x04, 0xf8, 0xcf, 0xf5, 0xc4, 0xef, 0x62, 0x0a, 0x28, 0xf0, - 0x9e, 0x46, 0xf4, 0x28, 0x05, 0x96, 0x77, 0x21, 0xf6, 0x3d, 0x7b, 0xcd, 0x91, 0x11, 0x40, 0x86, - 0x3e, 0x77, 0x3b, 0x5d, 0x56, 0x1c, 0xea, 0xdb, 0x8a, 0xbf, 0xd3, 0xc8, 0xe9, 0x7d, 0x41, 0xfc, - 0x97, 0x18, 0xf3, 0xdb, 0x1a, 0x79, 0xca, 0xd3, 0xe3, 0x5e, 0x3d, 0xce, 0x96, 0x4f, 0x90, 0x71, - 0x77, 0x6b, 0xb1, 0xca, 0xc1, 0x25, 0x54, 0x1e, 0x98, 0x41, 0x7f, 0xad, 0x78, 0x35, 0x0a, 0x08, - 0xda, 0xd3, 0x20, 0x69, 0xab, 0xde, 0x6d, 0xce, 0x8b, 0x3d, 0xcc, 0xa9, 0xca, 0x73, 0xad, 0xa9, - 0x0a, 0x19, 0x9c, 0x31, 0x4f, 0xfa, 0x2b, 0x58, 0x99, 0xb2, 0x93, 0x02, 0x1d, 0x7f, 0xe1, 0x05, - 0x87, 0xbf, 0x38, 0xdd, 0xf4, 0x9b, 0xe4, 0xa4, 0x97, 0xcb, 0xe4, 0x93, 0xaf, 0x9a, 0x7c, 0x6b, - 0xc3, 0x96, 0xfb, 0x90, 0xe7, 0xda, 0x2c, 0x19, 0xb7, 0x70, 0x00, 0x5c, 0x3b, 0x61, 0x74, 0xfa, - 0xfa, 0x1e, 0x99, 0x8f, 0x63, 0x46, 0xc8, 0x5f, 0x23, 0xd3, 0x56, 0x60, 0x04, 0x13, 0xd3, 0x95, - 0x04, 0xa8, 0x7d, 0x26, 0x04, 0xde, 0x25, 0x4a, 0xbf, 0x85, 0xd3, 0x07, 0x1f, 0xbe, 0x63, 0x0a, - 0x33, 0x09, 0xf8, 0x77, 0x49, 0x2e, 0x96, 0x1b, 0xd1, 0xff, 0x3f, 0x99, 0x52, 0xf7, 0x4c, 0xde, - 0xff, 0xde, 0x1b, 0x94, 0xa3, 0x57, 0xd0, 0xea, 0xe8, 0xe9, 0xb0, 0xd5, 0x07, 0x95, 0xcc, 0x3f, - 0xd6, 0xd0, 0x46, 0x11, 0x33, 0xed, 0xe3, 0xa2, 0xd4, 0x80, 0x5c, 0x34, 0xb8, 0xa5, 0x73, 0x13, - 0x4b, 0xa4, 0x15, 0x26, 0x36, 0x38, 0x5f, 0x2a, 0x97, 0x1d, 0xc6, 0x3b, 0x25, 0xd8, 0x3c, 0x49, - 0xcb, 0xb2, 0xa4, 0xd1, 0xdc, 0x2c, 0x3e, 0x64, 0xbb, 0xe8, 0xe9, 0x09, 0xc1, 0xf9, 0x5a, 0x73, - 0xf3, 0x35, 0xb6, 0xab, 0xbf, 0x4c, 0xb2, 0x51, 0xcc, 0x68, 0x80, 0x59, 0x92, 0x62, 0xc2, 0x8b, - 0x0f, 0xd9, 0x94, 0x94, 0x4d, 0x51, 0x02, 0xb8, 0x13, 0x86, 0x6c, 0x76, 0x6a, 0x16, 0x29, 0x61, - 0x7d, 0xdd, 0x5b, 0xb0, 0xaf, 0x61, 0xcd, 0xe2, 0x51, 0x51, 0xe0, 0x35, 0x92, 0xda, 0x58, 0x5f, - 0x47, 0xaf, 0x25, 0x28, 0x90, 0x0c, 0xf9, 0xb8, 0x5e, 0xc0, 0xb2, 0x6b, 0x85, 0x89, 0x15, 0x93, - 0xaf, 0xc9, 0x52, 0x5c, 0xd9, 0xaa, 0xac, 0x7a, 0x99, 0xed, 0x20, 0x46, 0xb7, 0xa3, 0x17, 0xb1, - 0x28, 0x0d, 0x30, 0xf8, 0x85, 0x9a, 0x47, 0x43, 0x1c, 0xe7, 0x7a, 0xe0, 0xe8, 0x88, 0xe8, 0x30, - 0xea, 0x26, 0x22, 0x5a, 0xaa, 0x56, 0xbb, 0x11, 0x0d, 0x2a, 0x3e, 0x7f, 0xac, 0xa1, 0x12, 0x81, - 0x39, 0x22, 0x95, 0x48, 0xf5, 0xa5, 0xc4, 0xe0, 0x22, 0x70, 0xc1, 0x0f, 0x22, 0x58, 0xc7, 0x6f, - 0xc0, 0x51, 0x6b, 0x7f, 0x17, 0x3d, 0xf4, 0x0b, 0xcf, 0x00, 0x0f, 0x2a, 0xb8, 0x4a, 0xd2, 0x0a, - 0x19, 0xcd, 0xd8, 0x2b, 0xa1, 0xab, 0x82, 0x54, 0x76, 0xbd, 0x8c, 0x00, 0x97, 0xaa, 0xd5, 0x08, - 0x80, 0x83, 0xf2, 0xd8, 0x07, 0x9a, 0xbf, 0x89, 0x25, 0xd2, 0x29, 0x75, 0x08, 0x9d, 0x06, 0xe7, - 0xbd, 0x79, 0x7f, 0x6f, 0x5d, 0x63, 0xf5, 0xb2, 0x55, 0xaf, 0x04, 0xcc, 0xa3, 0x0b, 0x3f, 0x23, - 0x77, 0x8d, 0xa3, 0x5e, 0xeb, 0x64, 0xba, 0xe1, 0x0e, 0xe0, 0x21, 0x1b, 0x55, 0xbb, 0xdc, 0xeb, - 0x40, 0x12, 0x90, 0x36, 0xd5, 0x50, 0xbb, 0xfa, 0x8b, 0xe4, 0x94, 0x7b, 0xe8, 0x51, 0xa9, 0x89, - 0x6b, 0x2b, 0xfd, 0x1b, 0x58, 0x9b, 0x45, 0xb3, 0x23, 0xf0, 0xaf, 0x46, 0x00, 0xd7, 0x0e, 0x0a, - 0xdc, 0xdb, 0xc6, 0x82, 0xf0, 0x17, 0xfd, 0xfd, 0x7f, 0xd5, 0xe4, 0x62, 0x59, 0x1e, 0xee, 0x5f, - 0x85, 0xb3, 0xfd, 0xfe, 0xcb, 0xe2, 0x11, 0x6e, 0xbd, 0x51, 0x7c, 0x88, 0xfa, 0x2b, 0x64, 0xa6, - 0x6b, 0x08, 0x61, 0xe7, 0x7b, 0xc0, 0xee, 0x16, 0xd8, 0x2d, 0x46, 0xdf, 0xf2, 0x77, 0xc4, 0x18, - 0xd0, 0x83, 0x5a, 0x2a, 0xbf, 0xd5, 0x50, 0xcf, 0xa8, 0xa9, 0xf6, 0xd3, 0x33, 0x35, 0x00, 0x3d, - 0x07, 0xb7, 0x74, 0x2e, 0xf9, 0xbb, 0x9c, 0x5a, 0xa2, 0x44, 0xbb, 0x76, 0x55, 0xc9, 0x92, 0xf0, - 0x36, 0x03, 0x42, 0xa5, 0xdf, 0x93, 0x76, 0x85, 0xcc, 0x05, 0xa7, 0x46, 0xab, 0xbd, 0x19, 0x7a, - 0x27, 0xa2, 0x1d, 0xb0, 0x2e, 0xeb, 0x7a, 0x1b, 0xf2, 0x36, 0xea, 0x28, 0x93, 0xda, 0x17, 0x50, - 0x86, 0xfd, 0x54, 0x43, 0x45, 0x3a, 0xf2, 0x63, 0x15, 0x49, 0x1d, 0x4a, 0x91, 0xc1, 0x79, 0xfd, - 0x9b, 0xca, 0x6e, 0x52, 0x12, 0x3b, 0x98, 0x0d, 0xbe, 0xc4, 0x03, 0xdf, 0x87, 0xea, 0x46, 0xa3, - 0x22, 0xf8, 0x8f, 0x37, 0xdd, 0x09, 0x34, 0x9d, 0x5c, 0x91, 0xf7, 0x99, 0x30, 0x03, 0xd9, 0x45, - 0xbf, 0x8e, 0x6a, 0x75, 0x8f, 0xa2, 0x5a, 0xc7, 0xc9, 0xa8, 0x92, 0xef, 0x52, 0x06, 0xf6, 0xf4, - 0x0d, 0xdc, 0xc0, 0x6e, 0xdb, 0xf5, 0x6d, 0xe6, 0xc8, 0x8a, 0x6f, 0xc3, 0x96, 0xec, 0xa1, 0xa5, - 0x15, 0x72, 0x48, 0x96, 0x8c, 0x57, 0x4c, 0xbe, 0x6a, 0xd5, 0x2c, 0x81, 0x25, 0x6d, 0xa7, 0xaf, - 0xff, 0x40, 0xc3, 0x7d, 0x2f, 0x2c, 0x16, 0xf1, 0x5c, 0x26, 0x47, 0xed, 0xa6, 0xd8, 0xb4, 0x9b, - 0xf5, 0xf2, 0x8a, 0xc9, 0xef, 0xd5, 0xe5, 0x20, 0x2e, 0xf9, 0xf0, 0x80, 0x7c, 0x1a, 0xde, 0x98, - 0x96, 0xec, 0xea, 0x5d, 0xc6, 0xf0, 0x69, 0x77, 0xd2, 0xf0, 0x00, 0x3d, 0x4f, 0x66, 0xe4, 0xaf, - 0x9a, 0xfc, 0x52, 0xb0, 0xfc, 0xbb, 0xc9, 0xfa, 0x39, 0x72, 0x06, 0x60, 0xbe, 0xce, 0x38, 0x37, - 0x2b, 0x6c, 0xcd, 0xe4, 0xdc, 0xaa, 0x57, 0xd6, 0x7c, 0x89, 0x9e, 0x75, 0xef, 0x92, 0xb3, 0xbd, - 0x1e, 0x44, 0xc5, 0x4e, 0x90, 0x89, 0x07, 0x1d, 0x88, 0x78, 0x64, 0xe8, 0x10, 0xf4, 0x9b, 0x38, - 0xe1, 0xfd, 0x57, 0xfe, 0xef, 0x75, 0x59, 0xde, 0x3b, 0x66, 0x9d, 0x9b, 0x25, 0xe9, 0x5e, 0x83, - 0x95, 0x98, 0xd5, 0xe8, 0x6c, 0x16, 0x94, 0x0c, 0x6f, 0xf9, 0xc7, 0x4b, 0x68, 0xeb, 0xff, 0x1a, - 0x46, 0x14, 0xfb, 0x70, 0x77, 0xcc, 0x4b, 0xf0, 0x9d, 0x78, 0x47, 0xc8, 0xf2, 0x54, 0xbb, 0x95, - 0x9b, 0x00, 0xaa, 0x3c, 0x49, 0x19, 0x7e, 0x93, 0x2e, 0x90, 0x49, 0xf7, 0xe9, 0x7a, 0xb3, 0xb6, - 0xc9, 0x1c, 0xd7, 0xb2, 0xcb, 0x33, 0xed, 0x56, 0x2e, 0x0d, 0xf4, 0x37, 0x80, 0x6c, 0xa8, 0x1d, - 0xfa, 0x12, 0x99, 0x2d, 0xd9, 0x75, 0xe1, 0x98, 0x25, 0x51, 0x34, 0xdd, 0xa3, 0x0f, 0x58, 0x79, - 0x62, 0xf9, 0x58, 0xbb, 0x95, 0x9b, 0xf1, 0xc6, 0xbc, 0x53, 0x51, 0x37, 0x81, 0xbe, 0x42, 0x8e, - 0x95, 0x9a, 0xb5, 0x66, 0xd5, 0x14, 0xd6, 0x36, 0x2b, 0x56, 0x4c, 0x5e, 0x6c, 0x72, 0x56, 0xce, - 0x0c, 0x83, 0x88, 0xc7, 0xda, 0xad, 0xdc, 0x51, 0x7f, 0x78, 0xc5, 0xe4, 0x6f, 0x71, 0x56, 0x36, - 0xc2, 0x24, 0x7a, 0x82, 0x0c, 0x3f, 0x70, 0xec, 0x5a, 0x66, 0x04, 0xf8, 0xc6, 0xdb, 0xad, 0x1c, - 0xf4, 0x0d, 0xf8, 0x4b, 0xcf, 0x42, 0x8c, 0xba, 0x92, 0x47, 0xe1, 0x89, 0x74, 0xbb, 0x95, 0x1b, - 0xab, 0xa0, 0x3c, 0xaf, 0x21, 0xcd, 0x55, 0xb5, 0x2b, 0xbc, 0xb8, 0x59, 0xb5, 0xed, 0x5a, 0x66, - 0xcc, 0x37, 0x97, 0xa4, 0x2e, 0x4b, 0xa2, 0xe1, 0x37, 0xa9, 0xde, 0x79, 0x35, 0x3f, 0x0e, 0x4f, - 0x92, 0x76, 0x2b, 0x87, 0x14, 0xef, 0xdd, 0x3b, 0x3d, 0x4e, 0x86, 0x84, 0x9d, 0x99, 0x80, 0xf1, - 0xd1, 0x76, 0x2b, 0x37, 0x24, 0x6c, 0x63, 0x48, 0xd8, 0xd2, 0x6c, 0xc2, 0x77, 0x9b, 0xeb, 0x1e, - 0xe2, 0x9b, 0x4d, 0x19, 0x03, 0x27, 0x75, 0x13, 0xe8, 0x12, 0x39, 0xaa, 0xf2, 0xbb, 0x5b, 0x65, - 0x1a, 0x04, 0xcc, 0xb5, 0x5b, 0x39, 0x55, 0xf8, 0x3d, 0x39, 0x66, 0x84, 0x28, 0x74, 0x91, 0x0c, - 0x4b, 0x5d, 0x32, 0x93, 0x89, 0xde, 0xb4, 0xaf, 0xda, 0x15, 0x03, 0x9e, 0xd7, 0xdf, 0x4b, 0x91, - 0xd4, 0xaa, 0x5d, 0x91, 0x29, 0xc1, 0x73, 0xb8, 0x1b, 0x9d, 0x5e, 0x57, 0x26, 0x19, 0x61, 0x37, - 0xac, 0x12, 0xcf, 0x0c, 0x9d, 0x4a, 0x9d, 0x9f, 0x30, 0xb0, 0x27, 0x83, 0xb9, 0x6c, 0x0a, 0xd3, - 0x8d, 0x0f, 0x03, 0xda, 0xa1, 0x98, 0x93, 0x8e, 0x1f, 0xee, 0x1d, 0x73, 0x21, 0xe3, 0x8d, 0x1c, - 0xd6, 0x78, 0xa3, 0x30, 0x71, 0x52, 0xe3, 0x05, 0x17, 0xd6, 0x58, 0x8f, 0x85, 0x75, 0x81, 0xc8, - 0xb0, 0xc1, 0x89, 0xc6, 0x61, 0xa2, 0xc9, 0x76, 0x2b, 0x37, 0x5e, 0xb5, 0x2b, 0xee, 0x04, 0x9d, - 0x16, 0x3d, 0x43, 0xc6, 0x1c, 0x56, 0xb3, 0xb7, 0x59, 0x19, 0xa2, 0x66, 0xdc, 0x8d, 0x54, 0x24, - 0x19, 0x5e, 0x43, 0xbf, 0x86, 0x65, 0x66, 0x54, 0x0a, 0x88, 0xcf, 0x1c, 0xff, 0x1c, 0xc6, 0x92, - 0x31, 0x8a, 0xed, 0x4b, 0x4b, 0x19, 0xde, 0x5a, 0x4d, 0x45, 0xae, 0xd5, 0x27, 0x48, 0xaa, 0x62, - 0x72, 0x4c, 0x00, 0x63, 0xed, 0x56, 0x4e, 0x76, 0x0d, 0xf9, 0x47, 0x9a, 0xb1, 0x73, 0x8f, 0x88, - 0x0e, 0x07, 0x33, 0x56, 0x3a, 0xe7, 0x72, 0xaf, 0x25, 0xe7, 0x00, 0xfc, 0xa3, 0xfe, 0x1c, 0xb2, - 0xef, 0xda, 0x81, 0xe6, 0x64, 0x71, 0xd9, 0x68, 0x0a, 0x74, 0xdc, 0x44, 0xbb, 0x95, 0x73, 0x09, - 0x86, 0xfb, 0x23, 0x1f, 0x70, 0xeb, 0xc5, 0x71, 0xff, 0x01, 0x20, 0x60, 0xe9, 0x18, 0xbb, 0xae, - 0x23, 0x43, 0x8b, 0x1c, 0x68, 0x5d, 0xe6, 0xc8, 0xc8, 0xb6, 0x59, 0x6d, 0x32, 0x5c, 0xce, 0x30, - 0x37, 0x10, 0x0c, 0xf7, 0x47, 0xea, 0x26, 0x76, 0x1b, 0x2c, 0x33, 0xe9, 0xeb, 0x26, 0xfb, 0x06, - 0xfc, 0xa5, 0x05, 0x92, 0x36, 0x4b, 0x25, 0xe6, 0xdd, 0xa3, 0x4d, 0xc9, 0x15, 0xb8, 0x3c, 0xdd, - 0x6e, 0xe5, 0x88, 0x4b, 0x5e, 0xb5, 0x64, 0x25, 0xe4, 0xb7, 0x65, 0x72, 0xec, 0x14, 0x5b, 0xd3, - 0x7e, 0x72, 0xc4, 0xfd, 0xdd, 0xdf, 0xe8, 0x8f, 0x11, 0x6d, 0x3b, 0x33, 0x03, 0x0f, 0x8c, 0xb4, - 0x5b, 0x39, 0x6d, 0xdb, 0xd0, 0xb6, 0x25, 0xd1, 0xc9, 0xcc, 0xfa, 0x44, 0xc7, 0xd0, 0x1c, 0x49, - 0xe4, 0x99, 0xa3, 0x3e, 0x91, 0x1b, 0x1a, 0xd7, 0x6f, 0xe0, 0x61, 0x14, 0x43, 0x0f, 0xb6, 0xdf, - 0xe5, 0x5d, 0x8c, 0x0f, 0x8c, 0xd9, 0xe3, 0x64, 0x74, 0xcb, 0xaf, 0x4e, 0x86, 0x0d, 0xec, 0xe9, - 0x7f, 0x19, 0xc3, 0xa3, 0x68, 0x34, 0x33, 0x46, 0xae, 0x4e, 0x46, 0x31, 0x0a, 0x35, 0x3f, 0x1f, - 0xbb, 0x14, 0x03, 0x7f, 0x3b, 0x71, 0x31, 0x14, 0x19, 0x17, 0x05, 0x92, 0x6e, 0x98, 0x0e, 0xab, - 0x0b, 0x37, 0xf8, 0xdd, 0x00, 0x05, 0xdb, 0xb9, 0x64, 0x88, 0x7e, 0xa5, 0xed, 0xc7, 0xc9, 0x70, - 0x4c, 0x9c, 0x14, 0x48, 0x9a, 0x6f, 0x99, 0xcf, 0x16, 0x9b, 0xf5, 0x52, 0x95, 0x71, 0x0c, 0x5a, - 0x90, 0x28, 0xc9, 0x6f, 0x01, 0xd5, 0x50, 0xda, 0x5d, 0x5b, 0xd0, 0x68, 0x8f, 0x2d, 0x28, 0x18, - 0x6e, 0xbc, 0xe8, 0xd8, 0xb6, 0x17, 0xd4, 0xdd, 0xe1, 0xc6, 0x0d, 0xdb, 0x16, 0x46, 0x88, 0x22, - 0x27, 0x94, 0x7b, 0x15, 0x73, 0x79, 0xc7, 0xfd, 0x09, 0x81, 0x0a, 0x4c, 0x7e, 0x93, 0x5e, 0x27, - 0x53, 0x8e, 0x5b, 0x63, 0xe0, 0x64, 0xee, 0x12, 0x98, 0x6d, 0xb7, 0x72, 0x93, 0xde, 0x00, 0xf0, - 0x04, 0x7a, 0xd2, 0x4e, 0x35, 0xab, 0xce, 0x1c, 0x5c, 0x0a, 0x60, 0x27, 0x20, 0x18, 0xee, 0x0f, - 0xcd, 0x13, 0x52, 0xb6, 0x1e, 0x3c, 0xb0, 0x4a, 0xcd, 0xaa, 0xd8, 0xc5, 0xc8, 0x07, 0x33, 0xf9, - 0x54, 0x43, 0x69, 0xc3, 0x16, 0x60, 0x0b, 0xb3, 0x5a, 0x54, 0xb8, 0x26, 0x95, 0x2d, 0x40, 0x8e, - 0xdd, 0xf1, 0x59, 0xbb, 0x09, 0x52, 0x6b, 0xb6, 0x23, 0x1c, 0xb3, 0x08, 0x1b, 0xd2, 0x94, 0xaf, - 0x35, 0x50, 0xe1, 0x35, 0xbd, 0xdf, 0x94, 0x51, 0xc3, 0xad, 0x77, 0x19, 0x2e, 0x0f, 0x88, 0x1a, - 0xd9, 0x37, 0xe0, 0xaf, 0x97, 0x96, 0xaa, 0x50, 0x02, 0xcf, 0x04, 0xd2, 0x12, 0x94, 0xc1, 0x7e, - 0x41, 0x1c, 0x28, 0x44, 0x66, 0xf7, 0x29, 0x44, 0x2e, 0x91, 0x09, 0x61, 0xd5, 0x18, 0x17, 0x66, - 0xad, 0x81, 0x2b, 0x09, 0xd0, 0x75, 0x88, 0x86, 0xdf, 0xa4, 0xd7, 0xc8, 0xa4, 0xea, 0xd5, 0x0c, - 0x85, 0x25, 0x0f, 0x2e, 0x09, 0x78, 0x3b, 0xd0, 0x93, 0xab, 0x05, 0x83, 0xf2, 0x18, 0x3c, 0x0f, - 0xab, 0xc5, 0xa5, 0x18, 0xf8, 0x4b, 0x6f, 0x90, 0x59, 0x79, 0x32, 0x29, 0x3e, 0x60, 0xac, 0xd8, - 0x60, 0x8e, 0x2c, 0xcf, 0x32, 0x73, 0x80, 0xe6, 0x68, 0xbb, 0x95, 0x9b, 0x92, 0x63, 0x77, 0x19, - 0x5b, 0x63, 0xce, 0x8a, 0xc9, 0x8d, 0x60, 0x57, 0xaa, 0x5a, 0xb3, 0xdc, 0xcf, 0x3a, 0x32, 0x8f, - 0xf9, 0xaa, 0xd6, 0x2c, 0x78, 0x81, 0x6f, 0x78, 0x8d, 0x85, 0x6f, 0x5d, 0x20, 0x23, 0xb0, 0xb6, - 0xe9, 0x77, 0x35, 0x32, 0xea, 0x5e, 0xb0, 0xd3, 0xab, 0x3d, 0xaa, 0x91, 0xf0, 0x0d, 0x7f, 0x76, - 0xe1, 0x20, 0x2c, 0x6e, 0xc6, 0xd0, 0xcf, 0xbc, 0xf7, 0xc7, 0x7f, 0x7c, 0x67, 0x28, 0x47, 0x4f, - 0x16, 0x24, 0xc7, 0x15, 0xe5, 0x5b, 0x16, 0xf5, 0x7b, 0x0f, 0xfa, 0xb1, 0x46, 0x26, 0xd5, 0x3b, - 0x51, 0x7a, 0x23, 0xc9, 0x5c, 0xd1, 0x9f, 0x03, 0x64, 0x6f, 0xf6, 0xc5, 0x8b, 0x80, 0x5f, 0x04, - 0xc0, 0xcf, 0xd1, 0xeb, 0x31, 0x80, 0xd5, 0x5b, 0xda, 0xc2, 0x23, 0x7c, 0xfb, 0xb1, 0x57, 0x78, - 0x04, 0xc9, 0x68, 0x8f, 0x7e, 0xa8, 0x91, 0x19, 0x55, 0xee, 0x52, 0xb5, 0x9a, 0x4c, 0x97, 0xe8, - 0x8f, 0x02, 0x92, 0xe9, 0x12, 0x73, 0xd1, 0xaf, 0x5f, 0x02, 0x5d, 0xce, 0xd0, 0xd3, 0x09, 0x74, - 0xa1, 0x7f, 0xd3, 0xc8, 0xf1, 0x2e, 0xe4, 0xf8, 0x26, 0x92, 0x2e, 0xf5, 0x01, 0x22, 0xf8, 0x12, - 0x34, 0xbb, 0x7c, 0x18, 0x11, 0xa8, 0xce, 0x0d, 0x50, 0xe7, 0x1a, 0x5d, 0x48, 0xa0, 0x0e, 0xf2, - 0xa2, 0x87, 0xf6, 0xe8, 0x5f, 0x35, 0xf2, 0x98, 0x72, 0x93, 0xaa, 0x28, 0xf7, 0x72, 0x42, 0x64, - 0xb1, 0x97, 0xe7, 0xd9, 0xa5, 0x43, 0x48, 0x40, 0xd5, 0x6e, 0x81, 0x6a, 0x8b, 0xf4, 0x5a, 0x8c, - 0x6a, 0x56, 0x3d, 0x46, 0xb3, 0xa2, 0x55, 0xde, 0xa3, 0x3f, 0xd7, 0xc8, 0x74, 0x50, 0xb9, 0xc4, - 0x31, 0x17, 0x71, 0x8d, 0x9d, 0x38, 0xe6, 0xa2, 0xee, 0xb8, 0x7b, 0xc6, 0x9c, 0xa2, 0x09, 0xa7, - 0xbf, 0x47, 0xe0, 0xca, 0x85, 0xe3, 0xad, 0x84, 0x8b, 0x37, 0xf2, 0xda, 0x35, 0xfb, 0x62, 0x9f, - 0xdc, 0x08, 0xfe, 0x79, 0x00, 0xbf, 0x40, 0x9f, 0xd9, 0x07, 0xbc, 0xcf, 0x56, 0x78, 0xe4, 0xf5, - 0xf7, 0xe8, 0x9f, 0x34, 0x42, 0xc3, 0x17, 0xd1, 0x34, 0x11, 0x9e, 0xd8, 0xeb, 0xef, 0xec, 0x4b, - 0xfd, 0xb2, 0xa3, 0x3e, 0x4b, 0xa0, 0xcf, 0x4d, 0xfa, 0x42, 0xac, 0x3e, 0xdd, 0xdf, 0x05, 0xc2, - 0x6e, 0xad, 0x2a, 0xf6, 0x2b, 0x8d, 0x1c, 0x0d, 0xce, 0x20, 0xc3, 0xeb, 0xd6, 0x01, 0x42, 0xa4, - 0x4f, 0x2f, 0xc5, 0x5e, 0x78, 0xeb, 0x57, 0x40, 0xab, 0x73, 0xf4, 0x4c, 0x22, 0x2f, 0xd1, 0x0f, - 0x34, 0x32, 0x15, 0xb8, 0x38, 0xa6, 0xcf, 0x27, 0x8c, 0x92, 0xd0, 0x45, 0x75, 0xf6, 0x85, 0x3e, - 0x38, 0x11, 0x75, 0x1e, 0x50, 0x9f, 0xa7, 0x67, 0x63, 0x50, 0x57, 0x98, 0x28, 0x0a, 0xce, 0xbd, - 0x57, 0x3c, 0xf4, 0x7d, 0x0d, 0x6e, 0xa1, 0x93, 0x6d, 0xd4, 0x81, 0x6b, 0xed, 0x64, 0x1b, 0x75, - 0xf0, 0xce, 0x5b, 0xd7, 0x01, 0xde, 0x09, 0x9a, 0x8d, 0x81, 0x27, 0xa1, 0xfc, 0x44, 0xf3, 0x2f, - 0x74, 0xe9, 0x62, 0xc2, 0x49, 0xba, 0x6e, 0x9e, 0xb3, 0xcf, 0x1d, 0x98, 0x0f, 0x11, 0x16, 0x00, - 0xe1, 0x05, 0x7a, 0x2e, 0xce, 0x80, 0xc8, 0x20, 0xa3, 0xb7, 0xcc, 0x76, 0xf6, 0xe8, 0x8f, 0x34, - 0x92, 0xf6, 0xa4, 0xc8, 0xa0, 0x5d, 0x4c, 0x18, 0x76, 0x7d, 0x21, 0x8e, 0xb8, 0xff, 0xd6, 0xcf, - 0x01, 0xe2, 0xa7, 0x68, 0xae, 0x07, 0x62, 0xfa, 0x91, 0x46, 0x66, 0xbb, 0x5f, 0xe0, 0xd2, 0x44, - 0x69, 0x38, 0xe6, 0x6d, 0x72, 0xf6, 0x56, 0x7f, 0xcc, 0x09, 0x4d, 0x5d, 0xea, 0xc6, 0xfa, 0xb1, - 0x46, 0xd2, 0xca, 0x3b, 0x5a, 0x7a, 0x27, 0xc9, 0xf4, 0xbd, 0xde, 0x05, 0x67, 0x5f, 0x39, 0xa4, - 0x14, 0xd4, 0xe6, 0x22, 0x68, 0xf3, 0x34, 0xd5, 0xe3, 0x6a, 0x50, 0x05, 0xf8, 0x2f, 0xb4, 0xc0, - 0xf5, 0x37, 0x4d, 0xba, 0xe0, 0xc3, 0x17, 0xf6, 0xd9, 0x1b, 0xfd, 0xb0, 0x22, 0xe4, 0x05, 0x80, - 0x7c, 0x99, 0x5e, 0x8c, 0x73, 0x80, 0xcf, 0xd3, 0x09, 0xf7, 0x9f, 0x69, 0x64, 0x5a, 0x91, 0x25, - 0x23, 0xfe, 0x85, 0x84, 0x91, 0xdb, 0x2f, 0xfa, 0xe8, 0x4f, 0x08, 0x7a, 0x1a, 0x5c, 0x41, 0x4f, - 0x7f, 0xa9, 0x91, 0xd9, 0xc0, 0x4d, 0xb5, 0xc4, 0x9d, 0xb4, 0x02, 0x89, 0xfa, 0x12, 0x20, 0x7b, - 0xab, 0x3f, 0x66, 0xc4, 0x7e, 0x19, 0xb0, 0x9f, 0xa5, 0x4f, 0xc7, 0x05, 0x8b, 0xca, 0x45, 0xff, - 0xa0, 0x91, 0xb9, 0xa8, 0xcb, 0x7b, 0xfa, 0x3f, 0x89, 0xce, 0x4a, 0xf1, 0x5f, 0x0d, 0x64, 0x5f, - 0xee, 0x5f, 0x00, 0x6a, 0xf2, 0x1c, 0x68, 0x72, 0x95, 0x16, 0x92, 0x68, 0xa2, 0x96, 0x93, 0x9f, - 0x68, 0xa1, 0x3b, 0x6d, 0x9a, 0xb4, 0xb0, 0x8a, 0xbe, 0x91, 0x4f, 0x56, 0xc8, 0xc4, 0x7f, 0x4d, - 0xa0, 0x2f, 0x82, 0x2e, 0xcf, 0xd0, 0x7c, 0x8c, 0x2e, 0xd5, 0x20, 0x5f, 0x67, 0x4d, 0xfc, 0x46, - 0x23, 0xb4, 0x4b, 0xa6, 0x8c, 0xaf, 0xa4, 0x05, 0xc8, 0x61, 0xb4, 0x89, 0xff, 0x66, 0xa0, 0x67, - 0x29, 0xd0, 0xa5, 0x0d, 0xfd, 0xbe, 0x46, 0x86, 0xa1, 0x94, 0x49, 0xba, 0xb1, 0xab, 0xc5, 0xd6, - 0xb3, 0x07, 0xe2, 0x49, 0x58, 0xc5, 0x97, 0xb0, 0xfc, 0x05, 0x23, 0x7f, 0x20, 0x73, 0xa6, 0xff, - 0xad, 0x40, 0xf2, 0x9c, 0x19, 0xfa, 0xbe, 0xa0, 0x3f, 0xb0, 0xd7, 0x01, 0x6c, 0x81, 0x5e, 0xd9, - 0x17, 0x6c, 0xe8, 0xa8, 0xfe, 0x3d, 0x8d, 0x8c, 0x79, 0xf5, 0xec, 0x42, 0xd2, 0x6c, 0x77, 0x50, - 0xc3, 0x76, 0x7d, 0x2f, 0xa0, 0x9f, 0x06, 0xac, 0x27, 0xe9, 0x93, 0xfb, 0x60, 0x75, 0x33, 0xb9, - 0x8b, 0x0c, 0x57, 0x78, 0xf2, 0x4c, 0x1e, 0xba, 0xea, 0x4f, 0x9e, 0xc9, 0xc3, 0x77, 0xf4, 0xbd, - 0x33, 0xb9, 0xcf, 0x03, 0xa7, 0xd0, 0xe0, 0x9d, 0x78, 0x32, 0xd4, 0x91, 0xb7, 0xec, 0xc9, 0x50, - 0x47, 0x5f, 0xc1, 0xf7, 0x3c, 0x20, 0x54, 0x83, 0x28, 0x7f, 0xa8, 0x11, 0xe2, 0xff, 0xaf, 0x0c, - 0xbd, 0x9e, 0x64, 0xe6, 0xd0, 0x7f, 0xdd, 0x64, 0x17, 0x0f, 0xca, 0x86, 0x60, 0x2f, 0x00, 0xd8, - 0xd3, 0xf4, 0xa9, 0x18, 0xb0, 0xc2, 0x47, 0xf6, 0xa1, 0x46, 0x26, 0xd5, 0x7f, 0x31, 0xa2, 0x89, - 0x2a, 0xd3, 0x88, 0xff, 0x79, 0xca, 0x3e, 0x7f, 0x70, 0x46, 0x84, 0x7b, 0x0d, 0xe0, 0xe6, 0xe9, - 0xe5, 0x7d, 0x22, 0x62, 0x13, 0x99, 0x0a, 0x8f, 0xdc, 0x3b, 0xda, 0xbd, 0xe5, 0xd7, 0x3e, 0xf9, - 0x6c, 0x5e, 0xfb, 0xf4, 0xb3, 0x79, 0xed, 0xef, 0x9f, 0xcd, 0x6b, 0xef, 0x7f, 0x3e, 0x7f, 0xe4, - 0xd3, 0xcf, 0xe7, 0x8f, 0xfc, 0xf9, 0xf3, 0xf9, 0x23, 0xf7, 0xaf, 0x56, 0x2c, 0xb1, 0xd5, 0xdc, - 0xcc, 0x97, 0xec, 0x9a, 0x2a, 0xd1, 0x03, 0x55, 0xd8, 0x09, 0xd8, 0x62, 0xb7, 0xc1, 0xf8, 0xe6, - 0x28, 0x14, 0x6c, 0xcf, 0xfe, 0x3b, 0x00, 0x00, 0xff, 0xff, 0x62, 0xb0, 0x08, 0xf4, 0xa1, 0x37, - 0x00, 0x00, + 0xd5, 0xf7, 0x8a, 0xb2, 0x2e, 0xa3, 0xfb, 0x58, 0x71, 0x18, 0xc6, 0x16, 0x9d, 0x75, 0x7c, 0xb7, + 0x49, 0x5b, 0xb1, 0x95, 0xc4, 0x76, 0xf2, 0x45, 0xf2, 0x45, 0x31, 0xa2, 0x24, 0xfa, 0x56, 0x4a, + 0x2f, 0x2e, 0x52, 0x62, 0xb5, 0x1c, 0x53, 0x0b, 0x93, 0x5c, 0x66, 0x67, 0x28, 0x48, 0x36, 0xd4, + 0x02, 0x79, 0xe8, 0x73, 0x80, 0x02, 0xed, 0x4b, 0x5f, 0x7b, 0x79, 0x68, 0x81, 0x02, 0x0d, 0x9a, + 0x16, 0x05, 0x52, 0x14, 0x6d, 0xd3, 0x3c, 0x06, 0x2d, 0x50, 0xf4, 0x02, 0x10, 0x45, 0xd2, 0x27, + 0xfe, 0x07, 0x05, 0xfa, 0x50, 0xcc, 0xd9, 0xb3, 0xdc, 0x59, 0x72, 0x57, 0x5c, 0x51, 0x4c, 0xd0, + 0xbe, 0x48, 0x33, 0x67, 0xe6, 0x9c, 0xf9, 0x9d, 0x33, 0x67, 0xce, 0x9c, 0x99, 0x59, 0x92, 0xa3, + 0x96, 0xeb, 0x70, 0x6e, 0x6d, 0x9a, 0x76, 0x35, 0xff, 0x4e, 0x9d, 0xb9, 0x3b, 0xb9, 0x9a, 0xeb, + 0x08, 0x87, 0x1e, 0x7f, 0xc4, 0x84, 0x09, 0xe4, 0x1c, 0x94, 0x1c, 0x97, 0xe5, 0x82, 0xae, 0x99, + 0xf3, 0x96, 0xc3, 0x2b, 0x0e, 0xcf, 0x6f, 0x98, 0x9c, 0x79, 0x7c, 0xf9, 0xad, 0x2b, 0x1b, 0x4c, + 0x98, 0x57, 0xf2, 0x35, 0xb3, 0x64, 0x57, 0x4d, 0x61, 0x3b, 0x55, 0x4f, 0x54, 0xe6, 0xb8, 0x32, + 0x04, 0xfc, 0x2d, 0x54, 0x9d, 0xaa, 0xc5, 0x38, 0x36, 0x67, 0xd5, 0x66, 0x59, 0x2c, 0x78, 0x9d, + 0xc4, 0x36, 0x76, 0xc8, 0x28, 0x1d, 0x4a, 0x26, 0x2f, 0xd4, 0x5c, 0xdb, 0x62, 0xd8, 0x76, 0x52, + 0x69, 0x03, 0x9e, 0xc2, 0xa6, 0xc9, 0x37, 0x0b, 0xc2, 0x29, 0x58, 0x56, 0x4b, 0xc0, 0x5c, 0x47, + 0x27, 0xe1, 0x9a, 0xd6, 0x43, 0xe6, 0x62, 0xbb, 0xae, 0xb4, 0x97, 0x4d, 0x2e, 0x0a, 0x1b, 0x65, + 0xc7, 0x7a, 0x58, 0xd8, 0x64, 0x76, 0x69, 0x53, 0x44, 0xc8, 0x00, 0xf8, 0x6d, 0x63, 0xa8, 0x5a, + 0x38, 0x75, 0xd1, 0x39, 0xc8, 0x93, 0x4a, 0x87, 0x9a, 0xe9, 0x9a, 0x15, 0x5f, 0xff, 0x59, 0xa5, + 0x41, 0xf0, 0x16, 0xb5, 0xe4, 0x94, 0x1c, 0x28, 0xe6, 0x65, 0x09, 0xa9, 0xc7, 0x4a, 0x8e, 0x53, + 0x2a, 0xb3, 0xbc, 0x59, 0xb3, 0xf3, 0x66, 0xb5, 0xea, 0x08, 0xb0, 0x33, 0xf2, 0xe8, 0xc7, 0x48, + 0xe6, 0xff, 0xe5, 0x54, 0xdc, 0x67, 0xc2, 0x5c, 0xb4, 0x2c, 0xa7, 0x5e, 0x15, 0x76, 0xb5, 0x64, + 0xb0, 0x77, 0xea, 0x8c, 0x0b, 0xfd, 0x27, 0x1a, 0x79, 0x3a, 0xb2, 0x99, 0xd7, 0x9c, 0x2a, 0x67, + 0x34, 0x47, 0x8e, 0x98, 0x1b, 0x8e, 0x2b, 0x58, 0xb1, 0x20, 0x67, 0xbc, 0x60, 0x56, 0x64, 0x8f, + 0xb4, 0x76, 0x42, 0x3b, 0x3b, 0x6a, 0xcc, 0x60, 0x13, 0xf0, 0x42, 0x03, 0xbd, 0x48, 0xa8, 0xdf, + 0x5f, 0xce, 0x0a, 0x76, 0x1f, 0x80, 0xee, 0xd3, 0xd8, 0xb2, 0x6c, 0x72, 0xec, 0x7d, 0x99, 0xcc, + 0xfa, 0xbd, 0x99, 0x6b, 0xcd, 0x5f, 0xf6, 0xfb, 0xa7, 0xa0, 0xbf, 0x2f, 0xe9, 0x8e, 0x6c, 0xf2, + 0x38, 0xf4, 0xb7, 0x49, 0x1a, 0xe0, 0xde, 0xb2, 0xc4, 0xf6, 0xd2, 0xce, 0x9a, 0x30, 0x45, 0x9d, + 0xa3, 0x2e, 0x74, 0x91, 0x0c, 0x71, 0x20, 0x00, 0xbc, 0xc9, 0xf9, 0x73, 0xb9, 0x3d, 0xdd, 0x35, + 0x27, 0x65, 0xa0, 0x04, 0x64, 0xd4, 0x5d, 0xf2, 0x54, 0x84, 0x78, 0xb4, 0xc5, 0x5b, 0x64, 0xfc, + 0x96, 0xe4, 0xbe, 0x25, 0xb9, 0xd7, 0xb7, 0xd3, 0xda, 0x89, 0xd4, 0xd9, 0xb1, 0xf9, 0x0b, 0xdd, + 0x46, 0x51, 0x58, 0x96, 0x06, 0x3f, 0x6e, 0x64, 0x0f, 0x19, 0x21, 0x31, 0x7a, 0x9a, 0x1c, 0x85, + 0x31, 0xd7, 0x39, 0x7f, 0xd5, 0xe6, 0xc2, 0x71, 0x77, 0xfc, 0xc9, 0xf9, 0x3a, 0x79, 0xb2, 0xa3, + 0x05, 0xb1, 0xdc, 0x22, 0x23, 0x82, 0xf3, 0x42, 0xd9, 0xe6, 0x02, 0x71, 0xe8, 0x5d, 0x70, 0xac, + 0xaf, 0xad, 0xe1, 0xf0, 0xc3, 0x82, 0xf3, 0x15, 0x9b, 0x0b, 0x7d, 0x96, 0x50, 0x90, 0xbf, 0x0a, + 0x9e, 0xe7, 0x8f, 0x7a, 0x9f, 0x1c, 0x09, 0x51, 0x5b, 0x23, 0x0e, 0x79, 0x1e, 0x0a, 0xd6, 0x1d, + 0x9b, 0x3f, 0xd5, 0x65, 0x3c, 0x8f, 0x1d, 0x87, 0x44, 0x56, 0xfd, 0x75, 0xf4, 0xb6, 0x65, 0x26, + 0xde, 0xac, 0x8b, 0xf5, 0xed, 0x75, 0x6f, 0x35, 0xf8, 0x33, 0x98, 0x26, 0xc3, 0xc0, 0x7c, 0xef, + 0x36, 0x0c, 0x92, 0x32, 0xfc, 0x2a, 0x9d, 0x25, 0x87, 0x61, 0x81, 0x81, 0x2b, 0x0d, 0x1a, 0x5e, + 0x45, 0xaf, 0x93, 0x63, 0xd1, 0xe2, 0x82, 0x19, 0x73, 0x14, 0x3a, 0x22, 0xef, 0x36, 0x63, 0xaa, + 0x28, 0x7f, 0xc6, 0x54, 0x31, 0x3a, 0x43, 0x2d, 0x16, 0xcb, 0xe5, 0x28, 0x2d, 0xee, 0x12, 0x12, + 0x84, 0x3b, 0x1c, 0xf3, 0x74, 0xce, 0x8b, 0x8d, 0x39, 0x19, 0x1b, 0x73, 0x5e, 0x4c, 0xc5, 0xd8, + 0x98, 0x5b, 0x35, 0x4b, 0x0c, 0x79, 0x0d, 0x85, 0x53, 0xff, 0x50, 0x43, 0xf5, 0x3a, 0xc6, 0x89, + 0x55, 0x2f, 0xd5, 0x07, 0xf5, 0xe8, 0x72, 0x08, 0xff, 0x00, 0xe0, 0x3f, 0xd3, 0x15, 0xbf, 0x87, + 0x29, 0xa4, 0xc0, 0xbb, 0x1a, 0xd1, 0xa3, 0x14, 0x58, 0xda, 0x01, 0xdf, 0xf7, 0xed, 0x35, 0x4b, + 0x0e, 0x03, 0x32, 0x9c, 0x73, 0xaf, 0xd2, 0x66, 0xc5, 0x81, 0x9e, 0xad, 0xf8, 0x7b, 0x8d, 0x9c, + 0xdc, 0x13, 0xc4, 0xff, 0x88, 0x31, 0xbf, 0xa5, 0x91, 0x67, 0x7c, 0x3d, 0xee, 0x55, 0xe3, 0x6c, + 0xf9, 0x14, 0x19, 0xf1, 0x36, 0x4a, 0xbb, 0x18, 0x5e, 0x42, 0xc5, 0xbe, 0x19, 0xf4, 0x37, 0xca, + 0xac, 0x46, 0x01, 0x41, 0x7b, 0x1a, 0x64, 0xcc, 0xae, 0xb6, 0x9b, 0xf3, 0x7c, 0x17, 0x73, 0xaa, + 0xf2, 0x3c, 0x6b, 0xaa, 0x42, 0xfa, 0x67, 0xcc, 0xe3, 0xc1, 0x0a, 0x56, 0x86, 0x6c, 0x85, 0x40, + 0x37, 0x58, 0x78, 0xe1, 0xe6, 0xcf, 0x4f, 0x37, 0xfd, 0x06, 0x39, 0xee, 0xc7, 0x32, 0xd9, 0xf3, + 0x55, 0x93, 0x6f, 0xae, 0x3b, 0x72, 0x1f, 0xf2, 0xa7, 0x36, 0x43, 0x46, 0x6c, 0x6c, 0xc0, 0xfd, + 0xb7, 0x55, 0xd7, 0x77, 0xc9, 0x5c, 0x1c, 0x33, 0x42, 0xfe, 0x1a, 0x99, 0xb4, 0x43, 0x2d, 0x18, + 0x98, 0x2e, 0x25, 0x40, 0x1d, 0x30, 0x21, 0xf0, 0x36, 0x51, 0xfa, 0x4d, 0x1c, 0x3e, 0xdc, 0xf9, + 0xb6, 0x29, 0xcc, 0x24, 0xe0, 0x1f, 0x91, 0x6c, 0x2c, 0x37, 0xa2, 0xff, 0x32, 0x99, 0x50, 0xf7, + 0x4c, 0xde, 0xfb, 0xde, 0x1b, 0x96, 0xa3, 0x97, 0xd0, 0xea, 0x38, 0xd3, 0x9d, 0x56, 0xef, 0x57, + 0x30, 0xff, 0x48, 0x43, 0x1b, 0x45, 0x8c, 0xb4, 0xc7, 0x14, 0xa5, 0xfa, 0x34, 0x45, 0xfd, 0x5b, + 0x3a, 0x37, 0x30, 0x45, 0x5a, 0x66, 0x62, 0x9d, 0xf3, 0xc5, 0x62, 0xd1, 0x65, 0xbc, 0x95, 0x82, + 0xcd, 0x91, 0x31, 0x99, 0x96, 0xd4, 0xea, 0x1b, 0x85, 0x87, 0x6c, 0x07, 0x67, 0x7a, 0x54, 0x70, + 0xbe, 0x5a, 0xdf, 0x78, 0x8d, 0xed, 0xe8, 0xaf, 0x60, 0x32, 0xda, 0xc6, 0x8c, 0x06, 0x98, 0x26, + 0x29, 0x26, 0x7c, 0xff, 0x90, 0x45, 0x49, 0xd9, 0x10, 0x16, 0xe6, 0x8f, 0xb2, 0xd8, 0xca, 0x59, + 0xa4, 0x84, 0xb5, 0x35, 0x7f, 0xc1, 0xbe, 0x86, 0x39, 0x8b, 0x4f, 0x45, 0x81, 0x57, 0x49, 0x6a, + 0x7d, 0x6d, 0x0d, 0x67, 0x2d, 0x41, 0x82, 0x64, 0xc8, 0xee, 0x7a, 0x1e, 0xd3, 0xae, 0x65, 0x26, + 0x96, 0x4d, 0xbe, 0x2a, 0x0f, 0x16, 0xca, 0x56, 0x65, 0x57, 0x8b, 0x6c, 0x1b, 0x31, 0x7a, 0x15, + 0xbd, 0x80, 0x49, 0x69, 0x88, 0x21, 0x48, 0xd4, 0x7c, 0x1a, 0xe2, 0x38, 0xd3, 0x05, 0x47, 0x4b, + 0x44, 0x8b, 0x51, 0x37, 0x11, 0xd1, 0x62, 0xb9, 0xdc, 0x8e, 0xa8, 0x5f, 0xfe, 0xf9, 0x23, 0x0d, + 0x95, 0x08, 0x8d, 0x11, 0xa9, 0x44, 0xaa, 0x27, 0x25, 0xfa, 0xe7, 0x81, 0xf3, 0x81, 0x13, 0xc1, + 0x3a, 0x7e, 0x03, 0x0e, 0x8e, 0x7b, 0x4f, 0xd1, 0xc3, 0x20, 0xf1, 0x0c, 0xf1, 0xa0, 0x82, 0x2b, + 0x64, 0x4c, 0x21, 0xa3, 0x19, 0xbb, 0x05, 0x74, 0x55, 0x90, 0xca, 0xae, 0x17, 0x11, 0xe0, 0x62, + 0xb9, 0x1c, 0x01, 0xb0, 0x5f, 0x33, 0xf6, 0xbe, 0x16, 0x6c, 0x62, 0x89, 0x74, 0x4a, 0x1d, 0x40, + 0xa7, 0xfe, 0xcd, 0xde, 0x5c, 0xb0, 0xb7, 0xae, 0xb2, 0x6a, 0xd1, 0xae, 0x96, 0x42, 0xe6, 0xd1, + 0x45, 0x10, 0x91, 0xdb, 0xda, 0x51, 0xaf, 0x35, 0x32, 0x59, 0xf3, 0x1a, 0xf0, 0xca, 0x00, 0x55, + 0xbb, 0xd8, 0xed, 0x40, 0x12, 0x92, 0x36, 0x51, 0x53, 0xab, 0xfa, 0x4b, 0xe4, 0x84, 0x77, 0xe8, + 0x51, 0xa9, 0x89, 0x73, 0x2b, 0xfd, 0x1b, 0x98, 0x9b, 0x45, 0xb3, 0x23, 0xf0, 0xaf, 0x46, 0x00, + 0xd7, 0xf6, 0x0b, 0xdc, 0xdf, 0xc6, 0xc2, 0xf0, 0x17, 0x82, 0xfd, 0x7f, 0xc5, 0xe4, 0x62, 0xa9, + 0xec, 0x58, 0x0f, 0x5f, 0x85, 0x9b, 0x8a, 0xbd, 0x97, 0xc5, 0x63, 0xdc, 0x7a, 0xa3, 0xf8, 0x10, + 0xf5, 0x57, 0xc8, 0x54, 0x5b, 0x13, 0xc2, 0xce, 0x75, 0x81, 0xdd, 0x2e, 0xb0, 0x5d, 0x8c, 0xbe, + 0x19, 0xec, 0x88, 0x31, 0xa0, 0xfb, 0xb5, 0x54, 0x7e, 0xa7, 0xa1, 0x9e, 0x51, 0x43, 0xed, 0xa5, + 0x67, 0xaa, 0x0f, 0x7a, 0xf6, 0x6f, 0xe9, 0x5c, 0x08, 0x76, 0x39, 0x35, 0x45, 0x89, 0x9e, 0xda, + 0x15, 0x25, 0x4a, 0xc2, 0x6d, 0x06, 0xb8, 0x4a, 0xaf, 0x27, 0xed, 0x12, 0x99, 0x0d, 0x0f, 0x8d, + 0x56, 0x7b, 0xb3, 0xe3, 0x4e, 0x44, 0xdb, 0x67, 0x5e, 0xd6, 0x76, 0x1b, 0xf2, 0x36, 0xea, 0x28, + 0x83, 0xda, 0xe7, 0x90, 0x86, 0xfd, 0x54, 0x43, 0x45, 0x5a, 0xf2, 0x63, 0x15, 0x49, 0x1d, 0x48, + 0x91, 0xfe, 0xcd, 0xfa, 0x37, 0x95, 0xdd, 0xc4, 0x12, 0xdb, 0x18, 0x0d, 0xbe, 0xc0, 0x03, 0xdf, + 0x07, 0xea, 0x46, 0xa3, 0x22, 0xf8, 0xaf, 0x37, 0x9d, 0x7f, 0xf7, 0x29, 0x57, 0xe4, 0x7d, 0x26, + 0xcc, 0x50, 0x74, 0xd1, 0xaf, 0xa1, 0x5a, 0xed, 0xad, 0xa8, 0xd6, 0x51, 0x32, 0xa4, 0xc4, 0xbb, + 0x94, 0x81, 0x35, 0x7d, 0x1d, 0x37, 0xb0, 0x5b, 0x4e, 0x75, 0x8b, 0xb9, 0x32, 0xe3, 0x5b, 0x77, + 0x24, 0x7b, 0xc7, 0xd2, 0xea, 0x98, 0x90, 0x0c, 0x19, 0x29, 0x99, 0x7c, 0xc5, 0xae, 0xd8, 0xfe, + 0x95, 0x68, 0xab, 0xae, 0x7f, 0x5f, 0xc3, 0x7d, 0xaf, 0x53, 0x2c, 0xe2, 0xb9, 0x48, 0x66, 0x9c, + 0xba, 0xd8, 0x70, 0xea, 0xd5, 0xe2, 0xb2, 0xc9, 0xef, 0x55, 0x65, 0xa3, 0x7f, 0x11, 0xdb, 0xd1, + 0x20, 0x7b, 0xc3, 0xfd, 0xaf, 0xe5, 0x94, 0xef, 0x32, 0x86, 0xbd, 0xbd, 0x41, 0x3b, 0x1b, 0xe8, + 0x59, 0x32, 0x25, 0xff, 0xab, 0xc1, 0x2f, 0x05, 0xcb, 0xbf, 0x9d, 0xac, 0x9f, 0x21, 0xa7, 0x00, + 0xe6, 0xeb, 0x8c, 0x73, 0xb3, 0xc4, 0x56, 0x4d, 0xce, 0xed, 0x6a, 0x69, 0x35, 0x90, 0xe8, 0x5b, + 0xf7, 0x2e, 0x39, 0xdd, 0xad, 0x23, 0x2a, 0x76, 0x8c, 0x8c, 0x3e, 0x68, 0x41, 0xc4, 0x23, 0x43, + 0x8b, 0xa0, 0xdf, 0xc0, 0x01, 0xef, 0xdf, 0xf9, 0xd2, 0xeb, 0x32, 0xbd, 0x77, 0xcd, 0x2a, 0x37, + 0x2d, 0x39, 0xbd, 0x06, 0xb3, 0x98, 0x5d, 0x6b, 0x6d, 0x16, 0x94, 0x0c, 0x6e, 0x06, 0xc7, 0x4b, + 0x28, 0xeb, 0xff, 0x1e, 0x44, 0x14, 0x7b, 0x70, 0xb7, 0xcc, 0x4b, 0xf0, 0x86, 0xbf, 0x25, 0x64, + 0x69, 0xa2, 0xd9, 0xc8, 0x8e, 0x02, 0x55, 0x9e, 0xa4, 0x8c, 0xa0, 0x48, 0xe7, 0xc9, 0xb8, 0xd7, + 0xbb, 0x5a, 0xaf, 0x6c, 0x30, 0xd7, 0xb3, 0xec, 0xd2, 0x54, 0xb3, 0x91, 0x1d, 0x03, 0xfa, 0x1b, + 0x40, 0x36, 0xd4, 0x0a, 0x7d, 0x99, 0x4c, 0x5b, 0x4e, 0x55, 0xb8, 0xa6, 0x25, 0x0a, 0xa6, 0x77, + 0xf4, 0xf1, 0x6e, 0xba, 0x97, 0x8e, 0x34, 0x1b, 0xd9, 0x29, 0xbf, 0xcd, 0x3f, 0x15, 0xb5, 0x13, + 0xe8, 0x1d, 0x72, 0xc4, 0xaa, 0x57, 0xea, 0x65, 0x53, 0xd8, 0x5b, 0x0c, 0xae, 0xd7, 0xeb, 0x9c, + 0x15, 0xd3, 0x83, 0x20, 0xe2, 0x89, 0x66, 0x23, 0x3b, 0x13, 0x34, 0x2f, 0x9b, 0xfc, 0x2d, 0xce, + 0x8a, 0x46, 0x27, 0x89, 0x1e, 0x23, 0x83, 0x0f, 0x5c, 0xa7, 0x92, 0x3e, 0x0c, 0x7c, 0x23, 0xcd, + 0x46, 0x16, 0xea, 0x06, 0xfc, 0xa5, 0xa7, 0xc1, 0x47, 0x3d, 0xc9, 0x43, 0xd0, 0x63, 0xac, 0xd9, + 0xc8, 0x0e, 0x97, 0x50, 0x9e, 0x5f, 0x90, 0xe6, 0x2a, 0x3b, 0x25, 0x5e, 0xd8, 0x28, 0x3b, 0x4e, + 0x25, 0x3d, 0x1c, 0x98, 0x4b, 0x52, 0x97, 0x24, 0xd1, 0x08, 0x8a, 0x54, 0x6f, 0x5d, 0xcd, 0x8f, + 0x40, 0x4f, 0xd2, 0x6c, 0x64, 0x91, 0xe2, 0xdf, 0xbd, 0xd3, 0xa3, 0x64, 0x40, 0x38, 0xe9, 0x51, + 0x68, 0x1f, 0x6a, 0x36, 0xb2, 0x03, 0xc2, 0x31, 0x06, 0x84, 0x23, 0xcd, 0x26, 0x82, 0x69, 0xf3, + 0xa6, 0x87, 0x04, 0x66, 0x53, 0xda, 0x60, 0x92, 0xda, 0x09, 0x74, 0x91, 0xcc, 0xa8, 0xfc, 0xde, + 0x56, 0x39, 0x06, 0x02, 0x66, 0x9b, 0x8d, 0xac, 0x2a, 0xfc, 0x9e, 0x6c, 0x33, 0x3a, 0x28, 0x74, + 0x81, 0x0c, 0x4a, 0x5d, 0xd2, 0xe3, 0x89, 0x6e, 0xda, 0x57, 0x9c, 0x92, 0x01, 0xfd, 0xf5, 0x77, + 0x53, 0x24, 0xb5, 0xe2, 0x94, 0x64, 0x48, 0xf0, 0x27, 0xdc, 0xf3, 0x4e, 0xbf, 0x2a, 0x83, 0x8c, + 0x70, 0x6a, 0xb6, 0xc5, 0xd3, 0x03, 0x27, 0x52, 0x67, 0x47, 0x0d, 0xac, 0x49, 0x67, 0x2e, 0x9a, + 0xc2, 0xc4, 0x97, 0x10, 0x28, 0x77, 0xf8, 0x9c, 0x9c, 0xf8, 0xc1, 0xee, 0x3e, 0xd7, 0x61, 0xbc, + 0xc3, 0x07, 0x35, 0xde, 0x10, 0x0c, 0x9c, 0xd4, 0x78, 0xe1, 0x85, 0x35, 0xdc, 0x65, 0x61, 0x9d, + 0x23, 0xd2, 0x6d, 0x70, 0xa0, 0x11, 0x18, 0x68, 0xbc, 0xd9, 0xc8, 0x8e, 0x94, 0x9d, 0x92, 0x37, + 0x40, 0xab, 0x44, 0x4f, 0x91, 0x61, 0x97, 0x55, 0x9c, 0x2d, 0x56, 0x04, 0xaf, 0x19, 0xf1, 0x3c, + 0x15, 0x49, 0x86, 0x5f, 0xd0, 0xaf, 0x62, 0x9a, 0x19, 0x15, 0x02, 0xe2, 0x23, 0xc7, 0xbf, 0x06, + 0x31, 0x65, 0x8c, 0x62, 0xfb, 0xc2, 0x42, 0x86, 0xbf, 0x56, 0x53, 0x91, 0x6b, 0xf5, 0x29, 0x92, + 0x2a, 0x99, 0x1c, 0x03, 0xc0, 0x70, 0xb3, 0x91, 0x95, 0x55, 0x43, 0xfe, 0x91, 0x66, 0x6c, 0xbd, + 0x8a, 0xe2, 0x84, 0x83, 0x19, 0x4b, 0xad, 0x73, 0xb9, 0x5f, 0x92, 0x63, 0x00, 0xfe, 0xa1, 0x60, + 0x0c, 0x59, 0xf7, 0xec, 0x40, 0xb3, 0x32, 0xb9, 0xac, 0xd5, 0x05, 0x4e, 0xdc, 0x68, 0xb3, 0x91, + 0xf5, 0x08, 0x86, 0xf7, 0x4f, 0x76, 0xf0, 0xf2, 0xc5, 0x91, 0xa0, 0x03, 0x10, 0x30, 0x75, 0x8c, + 0x5d, 0xd7, 0x91, 0xae, 0x45, 0xf6, 0xb5, 0x2e, 0xb3, 0xe4, 0xf0, 0x96, 0x59, 0xae, 0x33, 0x5c, + 0xce, 0x30, 0x36, 0x10, 0x0c, 0xef, 0x9f, 0xd4, 0x4d, 0xec, 0xd4, 0x58, 0x7a, 0x3c, 0xd0, 0x4d, + 0xd6, 0x0d, 0xf8, 0x4b, 0xf3, 0x64, 0xcc, 0xb4, 0x2c, 0xe6, 0xbf, 0xa3, 0x4d, 0xc8, 0x15, 0xb8, + 0x34, 0xd9, 0x6c, 0x64, 0x89, 0x47, 0x5e, 0xb1, 0x65, 0x26, 0x14, 0x94, 0x65, 0x70, 0x6c, 0x25, + 0x5b, 0x93, 0x41, 0x70, 0xc4, 0xfd, 0x3d, 0xd8, 0xe8, 0x8f, 0x10, 0x6d, 0x2b, 0x3d, 0x05, 0x1d, + 0x0e, 0x37, 0x1b, 0x59, 0x6d, 0xcb, 0xd0, 0xb6, 0x24, 0xd1, 0x4d, 0x4f, 0x07, 0x44, 0xd7, 0xd0, + 0x5c, 0x49, 0xe4, 0xe9, 0x99, 0x80, 0xc8, 0x0d, 0x8d, 0xeb, 0xd7, 0xf1, 0x30, 0x8a, 0xae, 0x07, + 0xdb, 0xef, 0xd2, 0x0e, 0xfa, 0x07, 0xfa, 0xec, 0x51, 0x32, 0xb4, 0x19, 0x64, 0x27, 0x83, 0x06, + 0xd6, 0xf4, 0xbf, 0x0e, 0xe3, 0x51, 0x34, 0x9a, 0x19, 0x3d, 0x57, 0x27, 0x43, 0xe8, 0x85, 0x5a, + 0x10, 0x8f, 0x3d, 0x8a, 0x81, 0xff, 0x5b, 0x7e, 0x31, 0x10, 0xe9, 0x17, 0x79, 0x32, 0x56, 0x33, + 0x5d, 0x56, 0x15, 0x9e, 0xf3, 0x7b, 0x0e, 0x0a, 0xb6, 0xf3, 0xc8, 0xe0, 0xfd, 0x4a, 0x39, 0xf0, + 0x93, 0xc1, 0x18, 0x3f, 0xc9, 0x93, 0x31, 0xbe, 0x69, 0x3e, 0x57, 0xa8, 0x57, 0xad, 0x32, 0xe3, + 0xe8, 0xb4, 0x20, 0x51, 0x92, 0xdf, 0x02, 0xaa, 0xa1, 0x94, 0xdb, 0xb6, 0xa0, 0xa1, 0x2e, 0x5b, + 0x50, 0xd8, 0xdd, 0x78, 0xc1, 0x75, 0x1c, 0xdf, 0xa9, 0xdb, 0xdd, 0x8d, 0x1b, 0x8e, 0x23, 0x8c, + 0x0e, 0x8a, 0x1c, 0x50, 0xee, 0x55, 0xcc, 0xe3, 0x1d, 0x09, 0x06, 0x04, 0x2a, 0x30, 0x05, 0x45, + 0x7a, 0x8d, 0x4c, 0xb8, 0x5e, 0x8e, 0x81, 0x83, 0x79, 0x4b, 0x60, 0xba, 0xd9, 0xc8, 0x8e, 0xfb, + 0x0d, 0xc0, 0x13, 0xaa, 0x49, 0x3b, 0x55, 0xec, 0x2a, 0x73, 0x71, 0x29, 0x80, 0x9d, 0x80, 0x60, + 0x78, 0xff, 0x68, 0x8e, 0x90, 0xa2, 0xfd, 0xe0, 0x81, 0x6d, 0xd5, 0xcb, 0x62, 0x07, 0x3d, 0x1f, + 0xcc, 0x14, 0x50, 0x0d, 0xa5, 0x0c, 0x5b, 0x80, 0x23, 0xcc, 0x72, 0x41, 0xe1, 0x1a, 0x57, 0xb6, + 0x00, 0xd9, 0x76, 0x3b, 0x60, 0x6d, 0x27, 0x48, 0xad, 0xd9, 0xb6, 0x70, 0xcd, 0x02, 0x6c, 0x48, + 0x13, 0x81, 0xd6, 0x40, 0x85, 0x6b, 0xfa, 0xa0, 0x28, 0xbd, 0x86, 0xdb, 0x8f, 0x18, 0x2e, 0x0f, + 0xf0, 0x1a, 0x59, 0x37, 0xe0, 0xaf, 0x1f, 0x96, 0xca, 0x90, 0x02, 0x4f, 0x85, 0xc2, 0x12, 0xa4, + 0xc1, 0x41, 0x42, 0x1c, 0x4a, 0x44, 0xa6, 0xf7, 0x48, 0x44, 0x2e, 0x90, 0x51, 0x61, 0x57, 0x18, + 0x17, 0x66, 0xa5, 0x86, 0x2b, 0x09, 0xd0, 0xb5, 0x88, 0x46, 0x50, 0xa4, 0x57, 0xc9, 0xb8, 0x3a, + 0xab, 0x69, 0x0a, 0x4b, 0x1e, 0xa6, 0x24, 0x34, 0xdb, 0xa1, 0x9a, 0x5c, 0x2d, 0xe8, 0x94, 0x47, + 0xa0, 0x3f, 0xac, 0x16, 0x8f, 0x62, 0xe0, 0x7f, 0x7a, 0x9d, 0x4c, 0xcb, 0x93, 0x49, 0xe1, 0x01, + 0x63, 0x85, 0x1a, 0x73, 0x65, 0x7a, 0x96, 0x9e, 0x05, 0x34, 0x33, 0xcd, 0x46, 0x76, 0x42, 0xb6, + 0xdd, 0x65, 0x6c, 0x95, 0xb9, 0xcb, 0x26, 0x37, 0xc2, 0x55, 0xa9, 0x6a, 0xc5, 0xf6, 0x3e, 0x52, + 0x49, 0x3f, 0x11, 0xa8, 0x5a, 0xb1, 0xe1, 0x02, 0xdf, 0xf0, 0x0b, 0xf3, 0xbf, 0x3c, 0x4f, 0x0e, + 0xc3, 0xda, 0xa6, 0xdf, 0xd1, 0xc8, 0x90, 0xf7, 0xc0, 0x4e, 0xaf, 0x74, 0xc9, 0x46, 0x3a, 0x5f, + 0xf8, 0x33, 0xf3, 0xfb, 0x61, 0xf1, 0x22, 0x86, 0x7e, 0xea, 0xdd, 0x3f, 0xfd, 0xf3, 0xdb, 0x03, + 0x59, 0x7a, 0x3c, 0x2f, 0x39, 0x2e, 0x29, 0x5f, 0xe6, 0xa8, 0x5f, 0xaf, 0xd0, 0x8f, 0x34, 0x32, + 0xae, 0xbe, 0x89, 0xd2, 0xeb, 0x49, 0xc6, 0x8a, 0xfe, 0x1c, 0x20, 0x73, 0xa3, 0x27, 0x5e, 0x04, + 0xfc, 0x12, 0x00, 0x7e, 0x9e, 0x5e, 0x8b, 0x01, 0xac, 0xbe, 0xd2, 0xe6, 0x1f, 0xe3, 0xed, 0xc7, + 0x6e, 0xfe, 0x31, 0x04, 0xa3, 0x5d, 0xfa, 0x81, 0x46, 0xa6, 0x54, 0xb9, 0x8b, 0xe5, 0x72, 0x32, + 0x5d, 0xa2, 0x3f, 0x0a, 0x48, 0xa6, 0x4b, 0xcc, 0x43, 0xbf, 0x7e, 0x01, 0x74, 0x39, 0x45, 0x4f, + 0x26, 0xd0, 0x85, 0xfe, 0x5d, 0x23, 0x47, 0xdb, 0x90, 0xe3, 0x4d, 0x24, 0x5d, 0xec, 0x01, 0x44, + 0xf8, 0x12, 0x34, 0xb3, 0x74, 0x10, 0x11, 0xa8, 0xce, 0x75, 0x50, 0xe7, 0x2a, 0x9d, 0x4f, 0xa0, + 0x0e, 0xf2, 0xe2, 0x0c, 0xed, 0xd2, 0xbf, 0x69, 0xe4, 0x09, 0xe5, 0x25, 0x55, 0x51, 0xee, 0x95, + 0x84, 0xc8, 0x62, 0x1f, 0xcf, 0x33, 0x8b, 0x07, 0x90, 0x80, 0xaa, 0xdd, 0x04, 0xd5, 0x16, 0xe8, + 0xd5, 0x18, 0xd5, 0xec, 0x6a, 0x8c, 0x66, 0x05, 0xbb, 0xb8, 0x4b, 0x7f, 0xae, 0x91, 0xc9, 0xb0, + 0x72, 0x89, 0x7d, 0x2e, 0xe2, 0x19, 0x3b, 0xb1, 0xcf, 0x45, 0xbd, 0x71, 0x77, 0xf5, 0x39, 0x45, + 0x13, 0x4e, 0xff, 0x80, 0xc0, 0x95, 0x07, 0xc7, 0x9b, 0x09, 0x17, 0x6f, 0xe4, 0xb3, 0x6b, 0xe6, + 0xa5, 0x1e, 0xb9, 0x11, 0xfc, 0x0b, 0x00, 0x7e, 0x9e, 0x5e, 0xde, 0x03, 0x7c, 0xc0, 0x96, 0x7f, + 0xec, 0xd7, 0x77, 0xe9, 0x9f, 0x35, 0x42, 0x3b, 0x1f, 0xa2, 0x69, 0x22, 0x3c, 0xb1, 0xcf, 0xdf, + 0x99, 0x97, 0x7b, 0x65, 0x47, 0x7d, 0x16, 0x41, 0x9f, 0x1b, 0xf4, 0xc5, 0x58, 0x7d, 0xda, 0xbf, + 0x72, 0x84, 0xdd, 0x5a, 0x55, 0xec, 0xd7, 0x1a, 0x99, 0x09, 0x8f, 0x20, 0xdd, 0xeb, 0xe6, 0x3e, + 0x5c, 0xa4, 0xc7, 0x59, 0x8a, 0x7d, 0xf0, 0xd6, 0x2f, 0x81, 0x56, 0x67, 0xe8, 0xa9, 0x44, 0xb3, + 0x44, 0xdf, 0xd7, 0xc8, 0x44, 0xe8, 0xe1, 0x98, 0xbe, 0x90, 0xd0, 0x4b, 0x3a, 0x1e, 0xaa, 0x33, + 0x2f, 0xf6, 0xc0, 0x89, 0xa8, 0x73, 0x80, 0xfa, 0x2c, 0x3d, 0x1d, 0x83, 0xba, 0xc4, 0x44, 0x41, + 0x70, 0xee, 0x5f, 0xf1, 0xd0, 0xf7, 0x34, 0x78, 0x85, 0x4e, 0xb6, 0x51, 0x87, 0x9e, 0xb5, 0x93, + 0x6d, 0xd4, 0xe1, 0x37, 0x6f, 0x5d, 0x07, 0x78, 0xc7, 0x68, 0x26, 0x06, 0x9e, 0x84, 0xf2, 0x63, + 0x2d, 0x78, 0xd0, 0xa5, 0x0b, 0x09, 0x07, 0x69, 0x7b, 0x79, 0xce, 0x3c, 0xbf, 0x6f, 0x3e, 0x44, + 0x98, 0x07, 0x84, 0xe7, 0xe8, 0x99, 0x38, 0x03, 0x22, 0x83, 0xf4, 0xde, 0x22, 0xdb, 0xde, 0xa5, + 0x3f, 0xd4, 0xc8, 0x98, 0x2f, 0x45, 0x3a, 0xed, 0x42, 0x42, 0xb7, 0xeb, 0x09, 0x71, 0xc4, 0xfb, + 0xb7, 0x7e, 0x06, 0x10, 0x3f, 0x43, 0xb3, 0x5d, 0x10, 0xd3, 0x0f, 0x35, 0x32, 0xdd, 0x7e, 0x81, + 0x4b, 0x13, 0x85, 0xe1, 0x98, 0xdb, 0xe4, 0xcc, 0xcd, 0xde, 0x98, 0x13, 0x9a, 0xda, 0x6a, 0xc7, + 0xfa, 0x91, 0x46, 0xc6, 0x94, 0x3b, 0x5a, 0x7a, 0x3b, 0xc9, 0xf0, 0xdd, 0xee, 0x82, 0x33, 0x77, + 0x0e, 0x28, 0x05, 0xb5, 0x39, 0x0f, 0xda, 0x3c, 0x4b, 0xf5, 0xb8, 0x1c, 0x54, 0x01, 0xfe, 0x0b, + 0x2d, 0xf4, 0xfc, 0x4d, 0x93, 0x2e, 0xf8, 0xce, 0x07, 0xfb, 0xcc, 0xf5, 0x5e, 0x58, 0x11, 0xf2, + 0x3c, 0x40, 0xbe, 0x48, 0xcf, 0xc7, 0x4d, 0x40, 0xc0, 0xd3, 0x72, 0xf7, 0x9f, 0x69, 0x64, 0x52, + 0x91, 0x25, 0x3d, 0xfe, 0xc5, 0x84, 0x9e, 0xdb, 0x2b, 0xfa, 0xe8, 0x4f, 0x08, 0xba, 0x1a, 0x5c, + 0x41, 0x4f, 0x7f, 0xa5, 0x91, 0xe9, 0xd0, 0x4b, 0xb5, 0xc4, 0x9d, 0x34, 0x03, 0x89, 0xfa, 0x12, + 0x20, 0x73, 0xb3, 0x37, 0x66, 0xc4, 0x7e, 0x11, 0xb0, 0x9f, 0xa6, 0xcf, 0xc6, 0x39, 0x8b, 0xca, + 0x45, 0xff, 0xa8, 0x91, 0xd9, 0xa8, 0xc7, 0x7b, 0xfa, 0x7f, 0x89, 0xce, 0x4a, 0xf1, 0x5f, 0x0d, + 0x64, 0x5e, 0xe9, 0x5d, 0x00, 0x6a, 0xf2, 0x3c, 0x68, 0x72, 0x85, 0xe6, 0x93, 0x68, 0xa2, 0xa6, + 0x93, 0x1f, 0x6b, 0x1d, 0x6f, 0xda, 0x34, 0x69, 0x62, 0x15, 0xfd, 0x22, 0x9f, 0x2c, 0x91, 0x89, + 0xff, 0x9a, 0x40, 0x5f, 0x00, 0x5d, 0x2e, 0xd3, 0x5c, 0x8c, 0x2e, 0xe5, 0x30, 0x5f, 0x6b, 0x4d, + 0xfc, 0x56, 0x23, 0xb4, 0x4d, 0xa6, 0xf4, 0xaf, 0xa4, 0x09, 0xc8, 0x41, 0xb4, 0x89, 0xff, 0x66, + 0xa0, 0x6b, 0x2a, 0xd0, 0xa6, 0x0d, 0xfd, 0x9e, 0x46, 0x06, 0x21, 0x95, 0x49, 0xba, 0xb1, 0xab, + 0xc9, 0xd6, 0x73, 0xfb, 0xe2, 0x49, 0x98, 0xc5, 0x5b, 0x98, 0xfe, 0x82, 0x91, 0xdf, 0x97, 0x31, + 0x33, 0xf8, 0x56, 0x20, 0x79, 0xcc, 0xec, 0xf8, 0xbe, 0xa0, 0x37, 0xb0, 0xd7, 0x00, 0x6c, 0x9e, + 0x5e, 0xda, 0x13, 0x6c, 0xc7, 0x51, 0xfd, 0xbb, 0x1a, 0x19, 0xf6, 0xf3, 0xd9, 0xf9, 0xa4, 0xd1, + 0x6e, 0xbf, 0x86, 0x6d, 0xfb, 0x5e, 0x40, 0x3f, 0x09, 0x58, 0x8f, 0xd3, 0xa7, 0xf7, 0xc0, 0xea, + 0x45, 0x72, 0x0f, 0x19, 0xae, 0xf0, 0xe4, 0x91, 0xbc, 0xe3, 0xa9, 0x3f, 0x79, 0x24, 0xef, 0x7c, + 0xa3, 0xef, 0x1e, 0xc9, 0x03, 0x1e, 0x38, 0x85, 0x86, 0xdf, 0xc4, 0x93, 0xa1, 0x8e, 0x7c, 0x65, + 0x4f, 0x86, 0x3a, 0xfa, 0x09, 0xbe, 0xeb, 0x01, 0xa1, 0x1c, 0x46, 0xf9, 0x03, 0x8d, 0x90, 0xe0, + 0xb7, 0x32, 0xf4, 0x5a, 0x92, 0x91, 0x3b, 0x7e, 0x75, 0x93, 0x59, 0xd8, 0x2f, 0x1b, 0x82, 0x3d, + 0x07, 0x60, 0x4f, 0xd2, 0x67, 0x62, 0xc0, 0x8a, 0x00, 0xd9, 0x07, 0x1a, 0x19, 0x57, 0x7f, 0x62, + 0x44, 0x13, 0x65, 0xa6, 0x11, 0xbf, 0x79, 0xca, 0xbc, 0xb0, 0x7f, 0x46, 0x84, 0x7b, 0x15, 0xe0, + 0xe6, 0xe8, 0xc5, 0x3d, 0x3c, 0x62, 0x03, 0x99, 0xf2, 0x8f, 0xbd, 0x37, 0x5a, 0xef, 0x86, 0x22, + 0xfc, 0x53, 0xb1, 0x64, 0xbe, 0x11, 0xf9, 0xeb, 0xb3, 0x64, 0xbe, 0x11, 0xfd, 0xcb, 0xb4, 0xae, + 0xbe, 0xf1, 0x28, 0xc4, 0xb6, 0xf4, 0xda, 0xc7, 0x9f, 0xce, 0x69, 0x9f, 0x7c, 0x3a, 0xa7, 0xfd, + 0xe3, 0xd3, 0x39, 0xed, 0xbd, 0xcf, 0xe6, 0x0e, 0x7d, 0xf2, 0xd9, 0xdc, 0xa1, 0xbf, 0x7c, 0x36, + 0x77, 0xe8, 0xfe, 0x95, 0x92, 0x2d, 0x36, 0xeb, 0x1b, 0x39, 0xcb, 0xa9, 0xa8, 0xa2, 0x7c, 0x3c, + 0xf9, 0xed, 0xd0, 0x24, 0xee, 0xd4, 0x18, 0xdf, 0x18, 0x82, 0x4c, 0xf3, 0xb9, 0xff, 0x04, 0x00, + 0x00, 0xff, 0xff, 0xbe, 0xb2, 0x73, 0x11, 0x28, 0x39, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -3628,6 +3732,7 @@ type QueryClient interface { LastZetaHeight(ctx context.Context, in *QueryLastZetaHeightRequest, opts ...grpc.CallOption) (*QueryLastZetaHeightResponse, error) TssHistory(ctx context.Context, in *QueryTssHistoryRequest, opts ...grpc.CallOption) (*QueryTssHistoryResponse, error) CctxByStatus(ctx context.Context, in *QueryCctxByStatusRequest, opts ...grpc.CallOption) (*QueryCctxByStatusResponse, error) + ZetaAccounting(ctx context.Context, in *QueryZetaAccountingRequest, opts ...grpc.CallOption) (*QueryZetaAccountingResponse, error) } type queryClient struct { @@ -3890,6 +3995,15 @@ func (c *queryClient) CctxByStatus(ctx context.Context, in *QueryCctxByStatusReq return out, nil } +func (c *queryClient) ZetaAccounting(ctx context.Context, in *QueryZetaAccountingRequest, opts ...grpc.CallOption) (*QueryZetaAccountingResponse, error) { + out := new(QueryZetaAccountingResponse) + err := c.cc.Invoke(ctx, "/zetachain.zetacore.crosschain.Query/ZetaAccounting", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // QueryServer is the server API for Query service. type QueryServer interface { // Parameters queries the parameters of the module. @@ -3939,6 +4053,7 @@ type QueryServer interface { LastZetaHeight(context.Context, *QueryLastZetaHeightRequest) (*QueryLastZetaHeightResponse, error) TssHistory(context.Context, *QueryTssHistoryRequest) (*QueryTssHistoryResponse, error) CctxByStatus(context.Context, *QueryCctxByStatusRequest) (*QueryCctxByStatusResponse, error) + ZetaAccounting(context.Context, *QueryZetaAccountingRequest) (*QueryZetaAccountingResponse, error) } // UnimplementedQueryServer can be embedded to have forward compatible implementations. @@ -4029,6 +4144,9 @@ func (*UnimplementedQueryServer) TssHistory(ctx context.Context, req *QueryTssHi func (*UnimplementedQueryServer) CctxByStatus(ctx context.Context, req *QueryCctxByStatusRequest) (*QueryCctxByStatusResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method CctxByStatus not implemented") } +func (*UnimplementedQueryServer) ZetaAccounting(ctx context.Context, req *QueryZetaAccountingRequest) (*QueryZetaAccountingResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ZetaAccounting not implemented") +} func RegisterQueryServer(s grpc1.Server, srv QueryServer) { s.RegisterService(&_Query_serviceDesc, srv) @@ -4538,6 +4656,24 @@ func _Query_CctxByStatus_Handler(srv interface{}, ctx context.Context, dec func( return interceptor(ctx, in, info, handler) } +func _Query_ZetaAccounting_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryZetaAccountingRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ZetaAccounting(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zetachain.zetacore.crosschain.Query/ZetaAccounting", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ZetaAccounting(ctx, req.(*QueryZetaAccountingRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _Query_serviceDesc = grpc.ServiceDesc{ ServiceName: "zetachain.zetacore.crosschain.Query", HandlerType: (*QueryServer)(nil), @@ -4654,11 +4790,82 @@ var _Query_serviceDesc = grpc.ServiceDesc{ MethodName: "CctxByStatus", Handler: _Query_CctxByStatus_Handler, }, + { + MethodName: "ZetaAccounting", + Handler: _Query_ZetaAccounting_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "crosschain/query.proto", } +func (m *QueryZetaAccountingRequest) 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 *QueryZetaAccountingRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryZetaAccountingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryZetaAccountingResponse) 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 *QueryZetaAccountingResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryZetaAccountingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.AbortedErc20Amount) > 0 { + i -= len(m.AbortedErc20Amount) + copy(dAtA[i:], m.AbortedErc20Amount) + i = encodeVarintQuery(dAtA, i, uint64(len(m.AbortedErc20Amount))) + i-- + dAtA[i] = 0x1a + } + if len(m.AbortedGasAmount) > 0 { + i -= len(m.AbortedGasAmount) + copy(dAtA[i:], m.AbortedGasAmount) + i = encodeVarintQuery(dAtA, i, uint64(len(m.AbortedGasAmount))) + i-- + dAtA[i] = 0x12 + } + if len(m.AbortedZetaAmount) > 0 { + i -= len(m.AbortedZetaAmount) + copy(dAtA[i:], m.AbortedZetaAmount) + i = encodeVarintQuery(dAtA, i, uint64(len(m.AbortedZetaAmount))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *QueryCctxByStatusRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -7219,6 +7426,36 @@ func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } +func (m *QueryZetaAccountingRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryZetaAccountingResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.AbortedZetaAmount) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.AbortedGasAmount) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.AbortedErc20Amount) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + func (m *QueryCctxByStatusRequest) Size() (n int) { if m == nil { return 0 @@ -8308,6 +8545,202 @@ func sovQuery(x uint64) (n int) { func sozQuery(x uint64) (n int) { return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } +func (m *QueryZetaAccountingRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryZetaAccountingRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryZetaAccountingRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryZetaAccountingResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryZetaAccountingResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryZetaAccountingResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AbortedZetaAmount", 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.AbortedZetaAmount = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AbortedGasAmount", 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.AbortedGasAmount = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AbortedErc20Amount", 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.AbortedErc20Amount = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *QueryCctxByStatusRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/x/crosschain/types/query.pb.gw.go b/x/crosschain/types/query.pb.gw.go index b4a9373a3a..981200b3a1 100644 --- a/x/crosschain/types/query.pb.gw.go +++ b/x/crosschain/types/query.pb.gw.go @@ -1217,6 +1217,24 @@ func local_request_Query_CctxByStatus_0(ctx context.Context, marshaler runtime.M } +func request_Query_ZetaAccounting_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryZetaAccountingRequest + var metadata runtime.ServerMetadata + + msg, err := client.ZetaAccounting(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_ZetaAccounting_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryZetaAccountingRequest + var metadata runtime.ServerMetadata + + msg, err := server.ZetaAccounting(ctx, &protoReq) + return msg, metadata, err + +} + // RegisterQueryHandlerServer registers the http handlers for service Query to "mux". // UnaryRPC :call QueryServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. @@ -1867,6 +1885,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) + mux.Handle("GET", pattern_Query_ZetaAccounting_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_ZetaAccounting_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_ZetaAccounting_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -2468,6 +2509,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) + mux.Handle("GET", pattern_Query_ZetaAccounting_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_ZetaAccounting_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_ZetaAccounting_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -2527,6 +2588,8 @@ var ( pattern_Query_TssHistory_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"zeta-chain", "crosschain", "tssHistory"}, "", runtime.AssumeColonVerbOpt(false))) pattern_Query_CctxByStatus_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"zeta-chain", "crosschain", "cctxbyStatus", "status"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Query_ZetaAccounting_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"zeta-chain", "crosschain", "zetaAccounting"}, "", runtime.AssumeColonVerbOpt(false))) ) var ( @@ -2585,4 +2648,6 @@ var ( forward_Query_TssHistory_0 = runtime.ForwardResponseMessage forward_Query_CctxByStatus_0 = runtime.ForwardResponseMessage + + forward_Query_ZetaAccounting_0 = runtime.ForwardResponseMessage ) diff --git a/zetaclient/query.go b/zetaclient/query.go index 76d4573572..12102fe3da 100644 --- a/zetaclient/query.go +++ b/zetaclient/query.go @@ -145,6 +145,15 @@ func (b *ZetaCoreBridge) GetCctxByStatus(status types.CctxStatus) ([]types.Cross return resp.CrossChainTx, nil } +func (b *ZetaCoreBridge) GetAbortedZetaAmount() (string, error) { + client := types.NewQueryClient(b.grpcConn) + resp, err := client.ZetaAccounting(context.Background(), &types.QueryZetaAccountingRequest{}) + if err != nil { + return "", err + } + return resp.AbortedZetaAmount, nil +} + func (b *ZetaCoreBridge) GetGenesisSupply() (sdkmath.Int, error) { tmURL := fmt.Sprintf("http://%s", b.cfg.ChainRPC) s, err := tmhttp.New(tmURL, "/websocket") diff --git a/zetaclient/zeta_supply_checker.go b/zetaclient/zeta_supply_checker.go index 13d40d3959..b51763f925 100644 --- a/zetaclient/zeta_supply_checker.go +++ b/zetaclient/zeta_supply_checker.go @@ -175,17 +175,13 @@ func ValidateZetaSupply(logger zerolog.Logger, abortedTxAmounts, zetaInTransit, } func (zs *ZetaSupplyChecker) AbortedTxAmount() (sdkmath.Int, error) { - cctxList, err := zs.zetaClient.GetCctxByStatus(types.CctxStatus_Aborted) + amount, err := zs.zetaClient.GetAbortedZetaAmount() if err != nil { - return sdkmath.ZeroInt(), err + return sdkmath.ZeroInt(), errors.Wrap(err, "error getting aborted zeta amount") } - amount := sdkmath.ZeroUint() - for _, cctx := range cctxList { - amount = amount.Add(cctx.GetCurrentOutTxParam().Amount) - } - amountInt, ok := sdkmath.NewIntFromString(amount.String()) + amountInt, ok := sdkmath.NewIntFromString(amount) if !ok { - return sdkmath.ZeroInt(), errors.New("error parsing amount") + return sdkmath.ZeroInt(), errors.New("error parsing aborted zeta amount") } return amountInt, nil }