diff --git a/cmd/zetaclientd/start.go b/cmd/zetaclientd/start.go index e82baec911..2a46dabdbd 100644 --- a/cmd/zetaclientd/start.go +++ b/cmd/zetaclientd/start.go @@ -115,6 +115,11 @@ func Start(_ *cobra.Command, _ []string) error { graceful.ShutdownNow() }) + maintenance.NewShutdownListener(zetacoreClient, logger.Std).Listen(ctx, func() { + logger.Std.Info().Msg("Shutdown listener received an action to shutdown zetaclientd.") + graceful.ShutdownNow() + }) + // CreateSignerMap: This creates a map of all signers for each chain. // Each signer is responsible for signing transactions for a particular chain signerMap, err := orchestrator.CreateSignerMap(ctx, tss, logger) diff --git a/cmd/zetacored/parse_genesis.go b/cmd/zetacored/parse_genesis.go index 89faf9bd2e..33150527e6 100644 --- a/cmd/zetacored/parse_genesis.go +++ b/cmd/zetacored/parse_genesis.go @@ -205,6 +205,8 @@ func ModifyObserverState( currentGenState := observertypes.GetGenesisStateFromAppState(cdc, appState) currentGenState.Ballots = importedObserverGenState.Ballots currentGenState.NonceToCctx = importedObserverGenState.NonceToCctx + // zero operational flags as they are network specific + currentGenState.OperationalFlags = observertypes.OperationalFlags{} currentGenStateBz, err := cdc.MarshalJSON(¤tGenState) if err != nil { diff --git a/cmd/zetae2e/config/clients.go b/cmd/zetae2e/config/clients.go index 26d1be9ba0..51c0ff617a 100644 --- a/cmd/zetae2e/config/clients.go +++ b/cmd/zetae2e/config/clients.go @@ -59,14 +59,15 @@ func getClientsFromConfig(ctx context.Context, conf config.Config, account confi } return runner.Clients{ - Zetacore: zetaCoreClients, - BtcRPC: btcRPCClient, - Solana: solanaClient, - TON: tonClient, - Evm: evmClient, - EvmAuth: evmAuth, - Zevm: zevmClient, - ZevmAuth: zevmAuth, + Zetacore: zetaCoreClients, + BtcRPC: btcRPCClient, + Solana: solanaClient, + TON: tonClient, + Evm: evmClient, + EvmAuth: evmAuth, + Zevm: zevmClient, + ZevmAuth: zevmAuth, + ZetaclientMetrics: &runner.MetricsClient{URL: conf.RPCs.ZetaclientMetrics}, }, nil } diff --git a/cmd/zetae2e/config/local.yml b/cmd/zetae2e/config/local.yml index d30a7b004c..af9dc0039c 100644 --- a/cmd/zetae2e/config/local.yml +++ b/cmd/zetae2e/config/local.yml @@ -109,6 +109,7 @@ rpcs: zetacore_rpc: "http://localhost:26657" solana: "http://localhost:8899" ton_sidecar_url: "http://localhost:8111" + zetaclient_metrics: "http://localhost:8886" contracts: zevm: system_contract: "0x91d18e54DAf4F677cB28167158d6dd21F6aB3921" diff --git a/cmd/zetae2e/config/localnet.yml b/cmd/zetae2e/config/localnet.yml index fb9943d916..ad7e2cd7e8 100644 --- a/cmd/zetae2e/config/localnet.yml +++ b/cmd/zetae2e/config/localnet.yml @@ -107,6 +107,7 @@ rpcs: ton_sidecar_url: "http://ton:8000" zetacore_grpc: "zetacore0:9090" zetacore_rpc: "http://zetacore0:26657" + zetaclient_metrics: "http://zetaclient0:8886" contracts: # configure localnet solana gateway program id solana: diff --git a/cmd/zetae2e/local/local.go b/cmd/zetae2e/local/local.go index c81b092eda..4385101a24 100644 --- a/cmd/zetae2e/local/local.go +++ b/cmd/zetae2e/local/local.go @@ -362,6 +362,7 @@ func localE2ETest(cmd *cobra.Command, _ []string) { if testAdmin { eg.Go(adminTestRoutine(conf, deployerRunner, verbose, + e2etests.TestOperationalFlagsName, e2etests.TestWhitelistERC20Name, e2etests.TestPauseZRC20Name, e2etests.TestUpdateBytecodeZRC20Name, diff --git a/contrib/localnet/docker-compose.yml b/contrib/localnet/docker-compose.yml index 5cb53b4e44..daa5a16440 100644 --- a/contrib/localnet/docker-compose.yml +++ b/contrib/localnet/docker-compose.yml @@ -114,6 +114,7 @@ services: restart: always ports: - "6061:6061" # pprof + - "8886:8886" # metrics volumes: - ssh:/root/.ssh - preparams:/root/preparams diff --git a/docs/cli/zetacored/cli.md b/docs/cli/zetacored/cli.md index 96c6e71510..56e293efe4 100644 --- a/docs/cli/zetacored/cli.md +++ b/docs/cli/zetacored/cli.md @@ -5394,6 +5394,7 @@ zetacored query observer [flags] * [zetacored query observer show-keygen](#zetacored-query-observer-show-keygen) - shows keygen * [zetacored query observer show-node-account](#zetacored-query-observer-show-node-account) - shows a NodeAccount * [zetacored query observer show-observer-count](#zetacored-query-observer-show-observer-count) - Query show-observer-count +* [zetacored query observer show-operational-flags](#zetacored-query-observer-show-operational-flags) - shows the operational flags * [zetacored query observer show-tss](#zetacored-query-observer-show-tss) - shows a TSS * [zetacored query observer show-tss-funds-migrator](#zetacored-query-observer-show-tss-funds-migrator) - show the tss funds migrator for a chain @@ -6101,6 +6102,40 @@ zetacored query observer show-observer-count [flags] * [zetacored query observer](#zetacored-query-observer) - Querying commands for the observer module +## zetacored query observer show-operational-flags + +shows the operational flags + +``` +zetacored query observer show-operational-flags [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 show-operational-flags + --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) + --log_no_color Disable colored logs + --trace print out full stack trace on errors +``` + +### SEE ALSO + +* [zetacored query observer](#zetacored-query-observer) - Querying commands for the observer module + ## zetacored query observer show-tss shows a TSS @@ -12767,6 +12802,7 @@ zetacored tx observer [flags] * [zetacored tx observer update-gas-price-increase-flags](#zetacored-tx-observer-update-gas-price-increase-flags) - Update the gas price increase flags * [zetacored tx observer update-keygen](#zetacored-tx-observer-update-keygen) - command to update the keygen block via a group proposal * [zetacored tx observer update-observer](#zetacored-tx-observer-update-observer) - Broadcast message add-observer +* [zetacored tx observer update-operational-flags](#zetacored-tx-observer-update-operational-flags) - Broadcast message UpdateOperationalFlags * [zetacored tx observer vote-blame](#zetacored-tx-observer-vote-blame) - Broadcast message vote-blame * [zetacored tx observer vote-tss](#zetacored-tx-observer-vote-tss) - Vote for a new TSS creation @@ -13300,6 +13336,61 @@ zetacored tx observer update-observer [old-observer-address] [new-observer-addre * [zetacored tx observer](#zetacored-tx-observer) - observer transactions subcommands +## zetacored tx observer update-operational-flags + +Broadcast message UpdateOperationalFlags + +``` +zetacored tx observer update-operational-flags [flags] +``` + +### Options + +``` + -a, --account-number uint The account number of the signing account (offline mode only) + --aux Generate aux signer data instead of sending a tx + -b, --broadcast-mode string Transaction broadcasting mode (sync|async) + --chain-id string The network chain ID + --dry-run ignore the --gas flag and perform a simulation of a transaction, but don't broadcast it (when enabled, the local Keybase is not accessible) + --fee-granter string Fee granter grants fees for the transaction + --fee-payer string Fee payer pays fees for the transaction instead of deducting from the signer + --fees string Fees to pay along with transaction; eg: 10uatom + --file string Path to a JSON file containing OperationalFlags + --from string Name or address of private key with which to sign + --gas string gas limit to set per-transaction; set to "auto" to calculate sufficient gas automatically. Note: "auto" option doesn't always report accurate results. Set a valid coin value to adjust the result. Can be used instead of "fees". (default 200000) + --gas-adjustment float adjustment factor to be multiplied against the estimate returned by the tx simulation; if the gas limit is set manually this flag is ignored (default 1) + --gas-prices string Gas prices in decimal format to determine the transaction fee (e.g. 0.1uatom) + --generate-only Build an unsigned transaction and write it to STDOUT (when enabled, the local Keybase only accessed when providing a key name) + -h, --help help for update-operational-flags + --keyring-backend string Select keyring's backend (os|file|kwallet|pass|test|memory) + --keyring-dir string The client Keyring directory; if omitted, the default 'home' directory will be used + --ledger Use a connected Ledger device + --node string [host]:[port] to tendermint rpc interface for this chain + --note string Note to add a description to the transaction (previously --memo) + --offline Offline mode (does not allow any online functionality) + -o, --output string Output format (text|json) + --restart-height int Height for a coordinated zetaclient restart + -s, --sequence uint The sequence number of the signing account (offline mode only) + --sign-mode string Choose sign mode (direct|amino-json|direct-aux), this is an advanced feature + --timeout-height uint Set a block timeout height to prevent the tx from being committed past a certain height + --tip string Tip is the amount that is going to be transferred to the fee payer on the target chain. This flag is only valid when used with --aux, and is ignored if the target chain didn't enable the TipDecorator + -y, --yes Skip tx broadcasting prompt confirmation +``` + +### Options inherited from parent commands + +``` + --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) + --log_no_color Disable colored logs + --trace print out full stack trace on errors +``` + +### SEE ALSO + +* [zetacored tx observer](#zetacored-tx-observer) - observer transactions subcommands + ## zetacored tx observer vote-blame Broadcast message vote-blame diff --git a/docs/openapi/openapi.swagger.yaml b/docs/openapi/openapi.swagger.yaml index f8162506bb..65f305da0f 100644 --- a/docs/openapi/openapi.swagger.yaml +++ b/docs/openapi/openapi.swagger.yaml @@ -30431,6 +30431,21 @@ paths: $ref: '#/definitions/googlerpcStatus' tags: - Query + /zeta-chain/observer/operationalFlags: + get: + summary: Queries operational flags + operationId: Query_OperationalFlags + responses: + "200": + description: A successful response. + schema: + $ref: '#/definitions/observerQueryOperationalFlagsResponse' + default: + description: An unexpected error response. + schema: + $ref: '#/definitions/googlerpcStatus' + tags: + - Query /zeta-chain/observer/pendingNonces: get: operationId: Query_PendingNoncesAll @@ -58018,6 +58033,8 @@ definitions: type: object observerMsgUpdateObserverResponse: type: object + observerMsgUpdateOperationalFlagsResponse: + type: object observerMsgVoteBlameResponse: type: object observerMsgVoteBlockHeaderResponse: @@ -58084,6 +58101,16 @@ definitions: - Tombstoned - AdminUpdate default: Undefined + observerOperationalFlags: + type: object + properties: + restart_height: + type: string + format: int64 + description: |- + Height for a coordinated zetaclient restart. + Will be ignored if missed. + description: Flags for the top-level operation of zetaclient. observerPendingNonces: type: object properties: @@ -58227,6 +58254,11 @@ definitions: type: array items: type: string + observerQueryOperationalFlagsResponse: + type: object + properties: + operational_flags: + $ref: '#/definitions/observerOperationalFlags' observerQueryPendingNoncesByChainResponse: type: object properties: diff --git a/docs/spec/observer/messages.md b/docs/spec/observer/messages.md index 045de79551..acceee29f2 100644 --- a/docs/spec/observer/messages.md +++ b/docs/spec/observer/messages.md @@ -164,3 +164,12 @@ message MsgUpdateGasPriceIncreaseFlags { } ``` +## MsgUpdateOperationalFlags + +```proto +message MsgUpdateOperationalFlags { + string creator = 1; + OperationalFlags operationalFlags = 2; +} +``` + diff --git a/e2e/config/config.go b/e2e/config/config.go index 5f0b67446a..e208ecb04c 100644 --- a/e2e/config/config.go +++ b/e2e/config/config.go @@ -94,13 +94,14 @@ type ObserverRelayerAccounts struct { // RPCs contains the configuration for the RPC endpoints type RPCs struct { - Zevm string `yaml:"zevm"` - EVM string `yaml:"evm"` - Bitcoin BitcoinRPC `yaml:"bitcoin"` - Solana string `yaml:"solana"` - TONSidecarURL string `yaml:"ton_sidecar_url"` - ZetaCoreGRPC string `yaml:"zetacore_grpc"` - ZetaCoreRPC string `yaml:"zetacore_rpc"` + Zevm string `yaml:"zevm"` + EVM string `yaml:"evm"` + Bitcoin BitcoinRPC `yaml:"bitcoin"` + Solana string `yaml:"solana"` + TONSidecarURL string `yaml:"ton_sidecar_url"` + ZetaCoreGRPC string `yaml:"zetacore_grpc"` + ZetaCoreRPC string `yaml:"zetacore_rpc"` + ZetaclientMetrics string `yaml:"zetaclient_metrics"` } // BitcoinRPC contains the configuration for the Bitcoin RPC endpoint diff --git a/e2e/e2etests/e2etests.go b/e2e/e2etests/e2etests.go index 46149e2346..cabc1e394f 100644 --- a/e2e/e2etests/e2etests.go +++ b/e2e/e2etests/e2etests.go @@ -130,8 +130,9 @@ const ( TestCriticalAdminTransactionsName = "critical_admin_transactions" TestPauseERC20CustodyName = "pause_erc20_custody" TestMigrateERC20CustodyFundsName = "migrate_erc20_custody_funds" - TestMigrateTSSName = "migrate_TSS" + TestMigrateTSSName = "migrate_tss" TestSolanaWhitelistSPLName = "solana_whitelist_spl" + TestOperationalFlagsName = "operational_flags" /* Operational tests @@ -878,7 +879,12 @@ var AllE2ETests = []runner.E2ETest{ []runner.ArgDefinition{}, TestMigrateERC20CustodyFunds, ), - + runner.NewE2ETest( + TestOperationalFlagsName, + "operational flags functionality", + []runner.ArgDefinition{}, + TestOperationalFlags, + ), /* Special tests */ diff --git a/e2e/e2etests/test_operational_flags.go b/e2e/e2etests/test_operational_flags.go new file mode 100644 index 0000000000..5084c38b58 --- /dev/null +++ b/e2e/e2etests/test_operational_flags.go @@ -0,0 +1,62 @@ +package e2etests + +import ( + "time" + + "github.com/stretchr/testify/require" + + "github.com/zeta-chain/node/e2e/runner" + "github.com/zeta-chain/node/e2e/utils" + observertypes "github.com/zeta-chain/node/x/observer/types" +) + +const ( + startTimestampMetricName = "zetaclient_last_start_timestamp_seconds" +) + +// TestOperationalFlags tests the functionality of operations flags. +func TestOperationalFlags(r *runner.E2ERunner, _ []string) { + _, err := r.Clients.Zetacore.Observer.OperationalFlags( + r.Ctx, + &observertypes.QueryOperationalFlagsRequest{}, + ) + require.NoError(r, err) + + currentHeight, err := r.Clients.Zetacore.GetBlockHeight(r.Ctx) + require.NoError(r, err) + + // schedule a restart for 5 blocks in the future + restartHeight := currentHeight + 5 + updateMsg := observertypes.NewMsgUpdateOperationalFlags( + r.ZetaTxServer.MustGetAccountAddressFromName(utils.OperationalPolicyName), + observertypes.OperationalFlags{ + RestartHeight: restartHeight, + }, + ) + + _, err = r.ZetaTxServer.BroadcastTx(utils.OperationalPolicyName, updateMsg) + require.NoError(r, err) + + operationalFlagsRes, err := r.Clients.Zetacore.Observer.OperationalFlags( + r.Ctx, + &observertypes.QueryOperationalFlagsRequest{}, + ) + require.NoError(r, err) + require.Equal(r, restartHeight, operationalFlagsRes.OperationalFlags.RestartHeight) + + originalStartTime, err := r.Clients.ZetaclientMetrics.FetchGauge(startTimestampMetricName) + require.NoError(r, err, "fetching zetaclient metric name") + + // wait for height above restart height + // wait for a few extra block to account for shutdown and startup time + require.Eventually(r, func() bool { + height, err := r.Clients.Zetacore.GetBlockHeight(r.Ctx) + require.NoError(r, err) + return height > restartHeight+3 + }, time.Minute, time.Second) + + currentStartTime, err := r.Clients.ZetaclientMetrics.FetchGauge(startTimestampMetricName) + require.NoError(r, err) + + require.Greater(r, currentStartTime, originalStartTime+1) +} diff --git a/e2e/runner/clients.go b/e2e/runner/clients.go index 2a67d43ffa..0c1508949b 100644 --- a/e2e/runner/clients.go +++ b/e2e/runner/clients.go @@ -1,10 +1,15 @@ package runner import ( + "fmt" + "net/http" + "github.com/btcsuite/btcd/rpcclient" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/ethclient" "github.com/gagliardetto/solana-go/rpc" + dto "github.com/prometheus/client_model/go" + "github.com/prometheus/common/expfmt" tonrunner "github.com/zeta-chain/node/e2e/runner/ton" zetacore_rpc "github.com/zeta-chain/node/pkg/rpc" @@ -24,4 +29,46 @@ type Clients struct { // the RPC clients for ZetaChain Zevm *ethclient.Client ZevmAuth *bind.TransactOpts + + ZetaclientMetrics *MetricsClient +} + +type MetricsClient struct { + URL string +} + +// Fetch retrieves and parses the prometheus metrics from the provided URL +func (m *MetricsClient) Fetch() (map[string]*dto.MetricFamily, error) { + // Fetch metrics + resp, err := http.Get(m.URL) + if err != nil { + return nil, fmt.Errorf("failed to fetch metrics: %w", err) + } + defer resp.Body.Close() + + // Parse metrics + parser := expfmt.TextParser{} + metricFamilies, err := parser.TextToMetricFamilies(resp.Body) + if err != nil { + return nil, fmt.Errorf("failed to parse metrics: %w", err) + } + + return metricFamilies, nil +} + +// FetchGauge fetches and individual gauge metric by it's name +func (m *MetricsClient) FetchGauge(name string) (float64, error) { + metrics, err := m.Fetch() + if err != nil { + return 0, err + } + metric, ok := metrics[name] + if !ok { + return 0, fmt.Errorf("%s metric is not found", name) + } + gauge := metric.Metric[0].Gauge + if gauge == nil { + return 0, fmt.Errorf("%s metric is not a gauge", name) + } + return *gauge.Value, nil } diff --git a/proto/zetachain/zetacore/observer/genesis.proto b/proto/zetachain/zetacore/observer/genesis.proto index e9af1fc51a..ce034d86b0 100644 --- a/proto/zetachain/zetacore/observer/genesis.proto +++ b/proto/zetachain/zetacore/observer/genesis.proto @@ -14,6 +14,7 @@ import "zetachain/zetacore/observer/params.proto"; import "zetachain/zetacore/observer/pending_nonces.proto"; import "zetachain/zetacore/observer/tss.proto"; import "zetachain/zetacore/observer/tss_funds_migrator.proto"; +import "zetachain/zetacore/observer/operational.proto"; option go_package = "github.com/zeta-chain/node/x/observer/types"; @@ -35,4 +36,5 @@ message GenesisState { repeated PendingNonces pending_nonces = 13 [ (gogoproto.nullable) = false ]; repeated ChainNonces chain_nonces = 14 [ (gogoproto.nullable) = false ]; repeated NonceToCctx nonce_to_cctx = 15 [ (gogoproto.nullable) = false ]; + OperationalFlags operational_flags = 16 [ (gogoproto.nullable) = false ]; } diff --git a/proto/zetachain/zetacore/observer/operational.proto b/proto/zetachain/zetacore/observer/operational.proto new file mode 100644 index 0000000000..f94c7e7d11 --- /dev/null +++ b/proto/zetachain/zetacore/observer/operational.proto @@ -0,0 +1,11 @@ +syntax = "proto3"; +package zetachain.zetacore.observer; + +option go_package = "github.com/zeta-chain/node/x/observer/types"; + +// Flags for the top-level operation of zetaclient. +message OperationalFlags { + // Height for a coordinated zetaclient restart. + // Will be ignored if missed. + int64 restart_height = 1; +} \ No newline at end of file diff --git a/proto/zetachain/zetacore/observer/query.proto b/proto/zetachain/zetacore/observer/query.proto index 65d5afb7b1..f58e3f9118 100644 --- a/proto/zetachain/zetacore/observer/query.proto +++ b/proto/zetachain/zetacore/observer/query.proto @@ -14,6 +14,7 @@ import "zetachain/zetacore/observer/observer.proto"; import "zetachain/zetacore/observer/params.proto"; import "zetachain/zetacore/observer/pending_nonces.proto"; import "zetachain/zetacore/observer/tss.proto"; +import "zetachain/zetacore/observer/operational.proto"; import "zetachain/zetacore/pkg/chains/chains.proto"; import "zetachain/zetacore/pkg/proofs/proofs.proto"; import "zetachain/zetacore/observer/tss_funds_migrator.proto"; @@ -164,6 +165,18 @@ service Query { option (google.api.http).get = "/zeta-chain/observer/getAllTssFundsMigrators"; } + + // Queries operational flags + rpc OperationalFlags(QueryOperationalFlagsRequest) + returns (QueryOperationalFlagsResponse) { + option (google.api.http).get = "/zeta-chain/observer/operationalFlags"; + } +} + +message QueryOperationalFlagsRequest {} + +message QueryOperationalFlagsResponse { + OperationalFlags operational_flags = 1 [ (gogoproto.nullable) = false ]; } message QueryTssFundsMigratorInfoAllRequest {} diff --git a/proto/zetachain/zetacore/observer/tx.proto b/proto/zetachain/zetacore/observer/tx.proto index 4086bb7e52..0d4ecf275e 100644 --- a/proto/zetachain/zetacore/observer/tx.proto +++ b/proto/zetachain/zetacore/observer/tx.proto @@ -8,6 +8,7 @@ import "zetachain/zetacore/observer/observer.proto"; import "zetachain/zetacore/observer/params.proto"; import "zetachain/zetacore/observer/pending_nonces.proto"; import "zetachain/zetacore/observer/tss.proto"; +import "zetachain/zetacore/observer/operational.proto"; import "zetachain/zetacore/pkg/chains/chains.proto"; import "zetachain/zetacore/pkg/proofs/proofs.proto"; @@ -31,6 +32,8 @@ service Msg { rpc DisableCCTX(MsgDisableCCTX) returns (MsgDisableCCTXResponse); rpc UpdateGasPriceIncreaseFlags(MsgUpdateGasPriceIncreaseFlags) returns (MsgUpdateGasPriceIncreaseFlagsResponse); + rpc UpdateOperationalFlags(MsgUpdateOperationalFlags) + returns (MsgUpdateOperationalFlagsResponse); } message MsgUpdateObserver { @@ -136,4 +139,11 @@ message MsgUpdateGasPriceIncreaseFlags { [ (gogoproto.nullable) = false ]; } -message MsgUpdateGasPriceIncreaseFlagsResponse {} \ No newline at end of file +message MsgUpdateGasPriceIncreaseFlagsResponse {} + +message MsgUpdateOperationalFlags { + string creator = 1; + OperationalFlags operationalFlags = 2 [ (gogoproto.nullable) = false ]; +} + +message MsgUpdateOperationalFlagsResponse {} diff --git a/testutil/sample/observer.go b/testutil/sample/observer.go index e9e8eb7cd7..aa8e0d82c4 100644 --- a/testutil/sample/observer.go +++ b/testutil/sample/observer.go @@ -284,3 +284,9 @@ func GasPriceIncreaseFlags() types.GasPriceIncreaseFlags { MaxPendingCctxs: 100, } } + +func OperationalFlags() types.OperationalFlags { + return types.OperationalFlags{ + RestartHeight: 1, + } +} diff --git a/typescript/zetachain/zetacore/observer/genesis_pb.d.ts b/typescript/zetachain/zetacore/observer/genesis_pb.d.ts index 357a08df3e..4faa22d72b 100644 --- a/typescript/zetachain/zetacore/observer/genesis_pb.d.ts +++ b/typescript/zetachain/zetacore/observer/genesis_pb.d.ts @@ -17,6 +17,7 @@ import type { Blame } from "./blame_pb.js"; import type { PendingNonces } from "./pending_nonces_pb.js"; import type { ChainNonces } from "./chain_nonces_pb.js"; import type { NonceToCctx } from "./nonce_to_cctx_pb.js"; +import type { OperationalFlags } from "./operational_pb.js"; /** * @generated from message zetachain.zetacore.observer.GenesisState @@ -99,6 +100,11 @@ export declare class GenesisState extends Message { */ nonceToCctx: NonceToCctx[]; + /** + * @generated from field: zetachain.zetacore.observer.OperationalFlags operational_flags = 16; + */ + operationalFlags?: OperationalFlags; + constructor(data?: PartialMessage); static readonly runtime: typeof proto3; diff --git a/typescript/zetachain/zetacore/observer/index.d.ts b/typescript/zetachain/zetacore/observer/index.d.ts index bb2d29105f..bdb0cde736 100644 --- a/typescript/zetachain/zetacore/observer/index.d.ts +++ b/typescript/zetachain/zetacore/observer/index.d.ts @@ -8,6 +8,7 @@ export * from "./keygen_pb"; export * from "./node_account_pb"; export * from "./nonce_to_cctx_pb"; export * from "./observer_pb"; +export * from "./operational_pb"; export * from "./params_pb"; export * from "./pending_nonces_pb"; export * from "./query_pb"; diff --git a/typescript/zetachain/zetacore/observer/operational_pb.d.ts b/typescript/zetachain/zetacore/observer/operational_pb.d.ts new file mode 100644 index 0000000000..5bae51a4e0 --- /dev/null +++ b/typescript/zetachain/zetacore/observer/operational_pb.d.ts @@ -0,0 +1,37 @@ +// @generated by protoc-gen-es v1.3.0 with parameter "target=dts" +// @generated from file zetachain/zetacore/observer/operational.proto (package zetachain.zetacore.observer, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3 } from "@bufbuild/protobuf"; + +/** + * Flags for the top-level operation of zetaclient. + * + * @generated from message zetachain.zetacore.observer.OperationalFlags + */ +export declare class OperationalFlags extends Message { + /** + * Height for a coordinated zetaclient restart. + * Will be ignored if missed. + * + * @generated from field: int64 restart_height = 1; + */ + restartHeight: bigint; + + constructor(data?: PartialMessage); + + static readonly runtime: typeof proto3; + static readonly typeName = "zetachain.zetacore.observer.OperationalFlags"; + static readonly fields: FieldList; + + static fromBinary(bytes: Uint8Array, options?: Partial): OperationalFlags; + + static fromJson(jsonValue: JsonValue, options?: Partial): OperationalFlags; + + static fromJsonString(jsonString: string, options?: Partial): OperationalFlags; + + static equals(a: OperationalFlags | PlainMessage | undefined, b: OperationalFlags | PlainMessage | undefined): boolean; +} + diff --git a/typescript/zetachain/zetacore/observer/query_pb.d.ts b/typescript/zetachain/zetacore/observer/query_pb.d.ts index 65f151c3be..2fbfdc9e8a 100644 --- a/typescript/zetachain/zetacore/observer/query_pb.d.ts +++ b/typescript/zetachain/zetacore/observer/query_pb.d.ts @@ -5,6 +5,7 @@ import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; import { Message, proto3 } from "@bufbuild/protobuf"; +import type { OperationalFlags } from "./operational_pb.js"; import type { TssFundMigratorInfo } from "./tss_funds_migrator_pb.js"; import type { ChainNonces } from "./chain_nonces_pb.js"; import type { PageRequest, PageResponse } from "../../../cosmos/base/query/v1beta1/pagination_pb.js"; @@ -19,6 +20,49 @@ import type { CrosschainFlags } from "./crosschain_flags_pb.js"; import type { Keygen } from "./keygen_pb.js"; import type { Blame } from "./blame_pb.js"; +/** + * @generated from message zetachain.zetacore.observer.QueryOperationalFlagsRequest + */ +export declare class QueryOperationalFlagsRequest extends Message { + constructor(data?: PartialMessage); + + static readonly runtime: typeof proto3; + static readonly typeName = "zetachain.zetacore.observer.QueryOperationalFlagsRequest"; + static readonly fields: FieldList; + + static fromBinary(bytes: Uint8Array, options?: Partial): QueryOperationalFlagsRequest; + + static fromJson(jsonValue: JsonValue, options?: Partial): QueryOperationalFlagsRequest; + + static fromJsonString(jsonString: string, options?: Partial): QueryOperationalFlagsRequest; + + static equals(a: QueryOperationalFlagsRequest | PlainMessage | undefined, b: QueryOperationalFlagsRequest | PlainMessage | undefined): boolean; +} + +/** + * @generated from message zetachain.zetacore.observer.QueryOperationalFlagsResponse + */ +export declare class QueryOperationalFlagsResponse extends Message { + /** + * @generated from field: zetachain.zetacore.observer.OperationalFlags operational_flags = 1; + */ + operationalFlags?: OperationalFlags; + + constructor(data?: PartialMessage); + + static readonly runtime: typeof proto3; + static readonly typeName = "zetachain.zetacore.observer.QueryOperationalFlagsResponse"; + static readonly fields: FieldList; + + static fromBinary(bytes: Uint8Array, options?: Partial): QueryOperationalFlagsResponse; + + static fromJson(jsonValue: JsonValue, options?: Partial): QueryOperationalFlagsResponse; + + static fromJsonString(jsonString: string, options?: Partial): QueryOperationalFlagsResponse; + + static equals(a: QueryOperationalFlagsResponse | PlainMessage | undefined, b: QueryOperationalFlagsResponse | PlainMessage | undefined): boolean; +} + /** * @generated from message zetachain.zetacore.observer.QueryTssFundsMigratorInfoAllRequest */ diff --git a/typescript/zetachain/zetacore/observer/tx_pb.d.ts b/typescript/zetachain/zetacore/observer/tx_pb.d.ts index dd02737886..9afe867fdf 100644 --- a/typescript/zetachain/zetacore/observer/tx_pb.d.ts +++ b/typescript/zetachain/zetacore/observer/tx_pb.d.ts @@ -11,6 +11,7 @@ import type { ChainParams } from "./params_pb.js"; import type { Blame } from "./blame_pb.js"; import type { ReceiveStatus } from "../pkg/chains/chains_pb.js"; import type { GasPriceIncreaseFlags } from "./crosschain_flags_pb.js"; +import type { OperationalFlags } from "./operational_pb.js"; /** * @generated from message zetachain.zetacore.observer.MsgUpdateObserver @@ -683,3 +684,51 @@ export declare class MsgUpdateGasPriceIncreaseFlagsResponse extends Message | undefined, b: MsgUpdateGasPriceIncreaseFlagsResponse | PlainMessage | undefined): boolean; } +/** + * @generated from message zetachain.zetacore.observer.MsgUpdateOperationalFlags + */ +export declare class MsgUpdateOperationalFlags extends Message { + /** + * @generated from field: string creator = 1; + */ + creator: string; + + /** + * @generated from field: zetachain.zetacore.observer.OperationalFlags operationalFlags = 2; + */ + operationalFlags?: OperationalFlags; + + constructor(data?: PartialMessage); + + static readonly runtime: typeof proto3; + static readonly typeName = "zetachain.zetacore.observer.MsgUpdateOperationalFlags"; + static readonly fields: FieldList; + + static fromBinary(bytes: Uint8Array, options?: Partial): MsgUpdateOperationalFlags; + + static fromJson(jsonValue: JsonValue, options?: Partial): MsgUpdateOperationalFlags; + + static fromJsonString(jsonString: string, options?: Partial): MsgUpdateOperationalFlags; + + static equals(a: MsgUpdateOperationalFlags | PlainMessage | undefined, b: MsgUpdateOperationalFlags | PlainMessage | undefined): boolean; +} + +/** + * @generated from message zetachain.zetacore.observer.MsgUpdateOperationalFlagsResponse + */ +export declare class MsgUpdateOperationalFlagsResponse extends Message { + constructor(data?: PartialMessage); + + static readonly runtime: typeof proto3; + static readonly typeName = "zetachain.zetacore.observer.MsgUpdateOperationalFlagsResponse"; + static readonly fields: FieldList; + + static fromBinary(bytes: Uint8Array, options?: Partial): MsgUpdateOperationalFlagsResponse; + + static fromJson(jsonValue: JsonValue, options?: Partial): MsgUpdateOperationalFlagsResponse; + + static fromJsonString(jsonString: string, options?: Partial): MsgUpdateOperationalFlagsResponse; + + static equals(a: MsgUpdateOperationalFlagsResponse | PlainMessage | undefined, b: MsgUpdateOperationalFlagsResponse | PlainMessage | undefined): boolean; +} + diff --git a/x/authority/types/authorization_list.go b/x/authority/types/authorization_list.go index 9e0da9b18f..6fe46f08fa 100644 --- a/x/authority/types/authorization_list.go +++ b/x/authority/types/authorization_list.go @@ -20,6 +20,7 @@ var ( "/zetachain.zetacore.observer.MsgUpdateChainParams", "/zetachain.zetacore.observer.MsgEnableCCTX", "/zetachain.zetacore.observer.MsgUpdateGasPriceIncreaseFlags", + "/zetachain.zetacore.observer.MsgUpdateOperationalFlags", } // AdminPolicyMessages keeps track of the message URLs that can, by default, only be executed by admin policy address AdminPolicyMessages = []string{ diff --git a/x/authority/types/authorization_list_test.go b/x/authority/types/authorization_list_test.go index 37bac846f7..dafa70ca27 100644 --- a/x/authority/types/authorization_list_test.go +++ b/x/authority/types/authorization_list_test.go @@ -399,6 +399,7 @@ func TestDefaultAuthorizationsList(t *testing.T) { sdk.MsgTypeURL(&observertypes.MsgUpdateChainParams{}), sdk.MsgTypeURL(&observertypes.MsgEnableCCTX{}), sdk.MsgTypeURL(&observertypes.MsgUpdateGasPriceIncreaseFlags{}), + sdk.MsgTypeURL(&observertypes.MsgUpdateOperationalFlags{}), } // EmergencyPolicyMessageList is a list of messages that can be authorized by the emergency policy diff --git a/x/observer/client/cli/query.go b/x/observer/client/cli/query.go index 65ebf2076a..04c773063b 100644 --- a/x/observer/client/cli/query.go +++ b/x/observer/client/cli/query.go @@ -43,6 +43,7 @@ func GetQueryCmd(_ string) *cobra.Command { CmdListPendingNonces(), CmdGetAllTssFundsMigrator(), CmdGetTssFundsMigrator(), + CmdShowOperationalFlags(), ) return cmd diff --git a/x/observer/client/cli/query_operational_flags.go b/x/observer/client/cli/query_operational_flags.go new file mode 100644 index 0000000000..15bdee971f --- /dev/null +++ b/x/observer/client/cli/query_operational_flags.go @@ -0,0 +1,37 @@ +package cli + +import ( + "context" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/spf13/cobra" + + "github.com/zeta-chain/node/x/observer/types" +) + +func CmdShowOperationalFlags() *cobra.Command { + cmd := &cobra.Command{ + Use: "show-operational-flags", + Short: "shows the operational flags", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + clientCtx := client.GetClientContextFromCmd(cmd) + + queryClient := types.NewQueryClient(clientCtx) + + params := &types.QueryOperationalFlagsRequest{} + + res, err := queryClient.OperationalFlags(context.Background(), params) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} diff --git a/x/observer/client/cli/tx.go b/x/observer/client/cli/tx.go index 471adf7ce0..4c10c3c636 100644 --- a/x/observer/client/cli/tx.go +++ b/x/observer/client/cli/tx.go @@ -32,6 +32,7 @@ func GetTxCmd() *cobra.Command { CmdEnableCCTX(), CmdDisableCCTX(), CmdUpdateGasPriceIncreaseFlags(), + CmdUpdateOperationalFlags(), ) return cmd diff --git a/x/observer/client/cli/tx_update_operational_flags.go b/x/observer/client/cli/tx_update_operational_flags.go new file mode 100644 index 0000000000..e730331cf9 --- /dev/null +++ b/x/observer/client/cli/tx_update_operational_flags.go @@ -0,0 +1,64 @@ +package cli + +import ( + "encoding/json" + "os" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/client/tx" + "github.com/spf13/cobra" + + "github.com/zeta-chain/node/x/observer/types" +) + +const ( + fileFlag = "file" + restartHeightFlag = "restart-height" +) + +func CmdUpdateOperationalFlags() *cobra.Command { + cmd := &cobra.Command{ + Use: "update-operational-flags", + Short: "Broadcast message UpdateOperationalFlags", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) (err error) { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + var operationalFlags types.OperationalFlags + + flagSet := cmd.Flags() + file, _ := flagSet.GetString(fileFlag) + restartHeight, _ := flagSet.GetInt64(restartHeightFlag) + + if file != "" { + input, err := os.ReadFile(file) // #nosec G304 + if err != nil { + return err + } + err = json.Unmarshal(input, &operationalFlags) + if err != nil { + return err + } + } else { + operationalFlags.RestartHeight = restartHeight + } + + msg := types.NewMsgUpdateOperationalFlags( + clientCtx.GetFromAddress().String(), + operationalFlags, + ) + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + cmd.Flags().String(fileFlag, "", "Path to a JSON file containing OperationalFlags") + cmd.Flags().Int64(restartHeightFlag, 0, "Height for a coordinated zetaclient restart") + flags.AddTxFlagsToCmd(cmd) + + return cmd +} diff --git a/x/observer/genesis.go b/x/observer/genesis.go index 12a92887c2..e852e407bf 100644 --- a/x/observer/genesis.go +++ b/x/observer/genesis.go @@ -130,6 +130,7 @@ func InitGenesis(ctx sdk.Context, k keeper.Keeper, genState types.GenesisState) for _, elem := range genState.NonceToCctx { k.SetNonceToCctx(ctx, elem) } + k.SetOperationalFlags(ctx, genState.OperationalFlags) } // ExportGenesis returns the observer module's exported genesis. @@ -185,6 +186,8 @@ func ExportGenesis(ctx sdk.Context, k keeper.Keeper) *types.GenesisState { os = observers } + of, _ := k.GetOperationalFlags(ctx) + return &types.GenesisState{ Ballots: k.GetAllBallots(ctx), ChainParamsList: chainParams, @@ -200,5 +203,6 @@ func ExportGenesis(ctx sdk.Context, k keeper.Keeper) *types.GenesisState { BlameList: k.GetAllBlame(ctx), ChainNonces: k.GetAllChainNonces(ctx), NonceToCctx: k.GetAllNonceToCctx(ctx), + OperationalFlags: of, } } diff --git a/x/observer/genesis_test.go b/x/observer/genesis_test.go index 13f9a54008..f0d9609bbc 100644 --- a/x/observer/genesis_test.go +++ b/x/observer/genesis_test.go @@ -39,9 +39,10 @@ func TestGenesis(t *testing.T) { sample.ChainNonces(1), sample.ChainNonces(2), }, - PendingNonces: sample.PendingNoncesList(t, "sample", 20), - NonceToCctx: sample.NonceToCctxList(t, "sample", 20), - TssHistory: []types.TSS{sample.Tss()}, + PendingNonces: sample.PendingNoncesList(t, "sample", 20), + NonceToCctx: sample.NonceToCctxList(t, "sample", 20), + TssHistory: []types.TSS{sample.Tss()}, + OperationalFlags: sample.OperationalFlags(), } // Init and export @@ -84,6 +85,7 @@ func TestGenesis(t *testing.T) { Keygen: &types.Keygen{}, LastObserverCount: &types.LastObserverCount{}, NodeAccountList: []*types.NodeAccount{}, + OperationalFlags: types.OperationalFlags{}, } require.Equal(t, expectedGenesisState, *got) @@ -148,6 +150,7 @@ func TestGenesis(t *testing.T) { BlameList: k.GetAllBlame(ctx), ChainNonces: k.GetAllChainNonces(ctx), NonceToCctx: k.GetAllNonceToCctx(ctx), + OperationalFlags: types.OperationalFlags{}, } require.Equal(t, expectedGenesisState, *got) diff --git a/x/observer/keeper/grpc_query_operational_flags.go b/x/observer/keeper/grpc_query_operational_flags.go new file mode 100644 index 0000000000..6800a1abb4 --- /dev/null +++ b/x/observer/keeper/grpc_query_operational_flags.go @@ -0,0 +1,26 @@ +package keeper + +import ( + "context" + + sdk "github.com/cosmos/cosmos-sdk/types" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + "github.com/zeta-chain/node/x/observer/types" +) + +func (k Keeper) OperationalFlags( + c context.Context, + req *types.QueryOperationalFlagsRequest, +) (*types.QueryOperationalFlagsResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + ctx := sdk.UnwrapSDKContext(c) + // ignoring found is intentional + operationalFlags, _ := k.GetOperationalFlags(ctx) + return &types.QueryOperationalFlagsResponse{ + OperationalFlags: operationalFlags, + }, nil +} diff --git a/x/observer/keeper/grpc_query_operational_flags_test.go b/x/observer/keeper/grpc_query_operational_flags_test.go new file mode 100644 index 0000000000..c7887d3db0 --- /dev/null +++ b/x/observer/keeper/grpc_query_operational_flags_test.go @@ -0,0 +1,33 @@ +package keeper_test + +import ( + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/require" + + keepertest "github.com/zeta-chain/node/testutil/keeper" + "github.com/zeta-chain/node/x/observer/types" +) + +func TestKeeper_OperationalFlags(t *testing.T) { + t.Run("should return operational flags", func(t *testing.T) { + k, ctx, _, _ := keepertest.ObserverKeeper(t) + wctx := sdk.WrapSDKContext(ctx) + + // should return zero value by default + res, err := k.OperationalFlags(wctx, &types.QueryOperationalFlagsRequest{}) + require.NoError(t, err) + require.Equal(t, types.OperationalFlags{}, res.OperationalFlags) + + // set the value and ensure it's returned by the query + restartHeight := int64(100) + k.SetOperationalFlags(ctx, types.OperationalFlags{ + RestartHeight: restartHeight, + }) + res, err = k.OperationalFlags(wctx, &types.QueryOperationalFlagsRequest{}) + require.NoError(t, err) + require.Equal(t, restartHeight, res.OperationalFlags.RestartHeight) + + }) +} diff --git a/x/observer/keeper/msg_server_update_operational_flags.go b/x/observer/keeper/msg_server_update_operational_flags.go new file mode 100644 index 0000000000..e93f31862b --- /dev/null +++ b/x/observer/keeper/msg_server_update_operational_flags.go @@ -0,0 +1,28 @@ +package keeper + +import ( + "context" + + "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" + + authoritytypes "github.com/zeta-chain/node/x/authority/types" + "github.com/zeta-chain/node/x/observer/types" +) + +func (k msgServer) UpdateOperationalFlags( + goCtx context.Context, + msg *types.MsgUpdateOperationalFlags, +) (*types.MsgUpdateOperationalFlagsResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + // check permission + err := k.GetAuthorityKeeper().CheckAuthorization(ctx, msg) + if err != nil { + return nil, errors.Wrap(authoritytypes.ErrUnauthorized, err.Error()) + } + + k.Keeper.SetOperationalFlags(ctx, msg.OperationalFlags) + + return &types.MsgUpdateOperationalFlagsResponse{}, nil +} diff --git a/x/observer/keeper/msg_server_update_operational_flags_test.go b/x/observer/keeper/msg_server_update_operational_flags_test.go new file mode 100644 index 0000000000..092c3ed6c1 --- /dev/null +++ b/x/observer/keeper/msg_server_update_operational_flags_test.go @@ -0,0 +1,77 @@ +package keeper_test + +import ( + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/require" + + keepertest "github.com/zeta-chain/node/testutil/keeper" + "github.com/zeta-chain/node/testutil/sample" + authoritytypes "github.com/zeta-chain/node/x/authority/types" + "github.com/zeta-chain/node/x/observer/keeper" + "github.com/zeta-chain/node/x/observer/types" +) + +func TestMsgServer_UpdateOperationalFlags(t *testing.T) { + t.Run("can update operational flags", func(t *testing.T) { + k, ctx, _, _ := keepertest.ObserverKeeperWithMocks(t, keepertest.ObserverMockOptions{ + UseAuthorityMock: true, + }) + srv := keeper.NewMsgServerImpl(*k) + + // set admin + admin := sample.AccAddress() + authorityMock := keepertest.GetObserverAuthorityMock(t, k) + + // test initial set + restartHeight := int64(100) + msg := types.MsgUpdateOperationalFlags{ + Creator: admin, + OperationalFlags: types.OperationalFlags{ + RestartHeight: restartHeight, + }, + } + keepertest.MockCheckAuthorization(&authorityMock.Mock, &msg, nil) + _, err := srv.UpdateOperationalFlags(sdk.WrapSDKContext(ctx), &msg) + require.NoError(t, err) + + operationalFlags, found := k.GetOperationalFlags(ctx) + require.True(t, found) + require.Equal(t, restartHeight, operationalFlags.RestartHeight) + + // verify that we can set it again + restartHeight = 101 + msg = types.MsgUpdateOperationalFlags{ + Creator: admin, + OperationalFlags: types.OperationalFlags{ + RestartHeight: restartHeight, + }, + } + keepertest.MockCheckAuthorization(&authorityMock.Mock, &msg, nil) + _, err = srv.UpdateOperationalFlags(sdk.WrapSDKContext(ctx), &msg) + require.NoError(t, err) + + operationalFlags, found = k.GetOperationalFlags(ctx) + require.True(t, found) + require.Equal(t, restartHeight, operationalFlags.RestartHeight) + }) + + t.Run("cannot update operational flags if not authorized", func(t *testing.T) { + k, ctx, _, _ := keepertest.ObserverKeeperWithMocks(t, keepertest.ObserverMockOptions{ + UseAuthorityMock: true, + }) + srv := keeper.NewMsgServerImpl(*k) + admin := sample.AccAddress() + authorityMock := keepertest.GetObserverAuthorityMock(t, k) + + msg := types.MsgUpdateOperationalFlags{ + Creator: admin, + OperationalFlags: sample.OperationalFlags(), + } + keepertest.MockCheckAuthorization(&authorityMock.Mock, &msg, authoritytypes.ErrUnauthorized) + _, err := srv.UpdateOperationalFlags(sdk.WrapSDKContext(ctx), &msg) + + require.ErrorIs(t, err, authoritytypes.ErrUnauthorized) + }) +} diff --git a/x/observer/keeper/operational_flags.go b/x/observer/keeper/operational_flags.go new file mode 100644 index 0000000000..e9854d1149 --- /dev/null +++ b/x/observer/keeper/operational_flags.go @@ -0,0 +1,26 @@ +package keeper + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/zeta-chain/node/x/observer/types" +) + +func (k Keeper) SetOperationalFlags(ctx sdk.Context, operationalFlags types.OperationalFlags) { + store := ctx.KVStore(k.storeKey) + b := k.cdc.MustMarshal(&operationalFlags) + key := types.KeyPrefix(types.OperationalFlagsKey) + store.Set(key, b) +} + +func (k Keeper) GetOperationalFlags(ctx sdk.Context) (val types.OperationalFlags, found bool) { + found = false + store := ctx.KVStore(k.storeKey) + b := store.Get(types.KeyPrefix(types.OperationalFlagsKey)) + if b == nil { + return + } + found = true + k.cdc.MustUnmarshal(b, &val) + return +} diff --git a/x/observer/keeper/operational_flags_test.go b/x/observer/keeper/operational_flags_test.go new file mode 100644 index 0000000000..451893ea8d --- /dev/null +++ b/x/observer/keeper/operational_flags_test.go @@ -0,0 +1,29 @@ +package keeper_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + keepertest "github.com/zeta-chain/node/testutil/keeper" + "github.com/zeta-chain/node/x/observer/types" +) + +func TestOperationalFlagsKeeper(t *testing.T) { + k, ctx, _, _ := keepertest.ObserverKeeper(t) + + // found should be false on first run + // we do not store a genesis value for the flags since + // all fields default to zero value + _, found := k.GetOperationalFlags(ctx) + require.False(t, found) + + restartHeight := int64(100) + + k.SetOperationalFlags(ctx, types.OperationalFlags{ + RestartHeight: restartHeight, + }) + + operationalFlags, found := k.GetOperationalFlags(ctx) + require.True(t, found) + require.Equal(t, restartHeight, operationalFlags.RestartHeight) +} diff --git a/x/observer/types/codec.go b/x/observer/types/codec.go index 778caed484..3e65c90bc8 100644 --- a/x/observer/types/codec.go +++ b/x/observer/types/codec.go @@ -20,6 +20,7 @@ func RegisterCodec(cdc *codec.LegacyAmino) { cdc.RegisterConcrete(&MsgEnableCCTX{}, "observer/EnableCCTX", nil) cdc.RegisterConcrete(&MsgDisableCCTX{}, "observer/DisableCCTX", nil) cdc.RegisterConcrete(&MsgUpdateGasPriceIncreaseFlags{}, "observer/UpdateGasPriceIncreaseFlags", nil) + cdc.RegisterConcrete(&MsgUpdateOperationalFlags{}, "observer/UpdateOperationalFlags", nil) } func RegisterInterfaces(registry cdctypes.InterfaceRegistry) { @@ -36,6 +37,7 @@ func RegisterInterfaces(registry cdctypes.InterfaceRegistry) { &MsgEnableCCTX{}, &MsgDisableCCTX{}, &MsgUpdateGasPriceIncreaseFlags{}, + &MsgUpdateOperationalFlags{}, ) msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) diff --git a/x/observer/types/errors.go b/x/observer/types/errors.go index 218521f242..edfd3040a1 100644 --- a/x/observer/types/errors.go +++ b/x/observer/types/errors.go @@ -46,10 +46,11 @@ var ( ErrObserverSetNotFound = errorsmod.Register(ModuleName, 1130, "observer set not found") ErrTssNotFound = errorsmod.Register(ModuleName, 1131, "tss not found") - ErrInboundDisabled = errorsmod.Register(ModuleName, 1132, "inbound tx processing is disabled") - ErrInvalidZetaCoinTypes = errorsmod.Register(ModuleName, 1133, "invalid zeta coin types") - ErrNotObserver = errorsmod.Register(ModuleName, 1134, "sender is not an observer") - ErrDuplicateObserver = errorsmod.Register(ModuleName, 1135, "observer already exists") - ErrObserverNotFound = errorsmod.Register(ModuleName, 1136, "observer not found") - ErrInvalidObserverAddress = errorsmod.Register(ModuleName, 1137, "invalid observer address") + ErrInboundDisabled = errorsmod.Register(ModuleName, 1132, "inbound tx processing is disabled") + ErrInvalidZetaCoinTypes = errorsmod.Register(ModuleName, 1133, "invalid zeta coin types") + ErrNotObserver = errorsmod.Register(ModuleName, 1134, "sender is not an observer") + ErrDuplicateObserver = errorsmod.Register(ModuleName, 1135, "observer already exists") + ErrObserverNotFound = errorsmod.Register(ModuleName, 1136, "observer not found") + ErrInvalidObserverAddress = errorsmod.Register(ModuleName, 1137, "invalid observer address") + ErrOperationalFlagsRestartHeightNegative = errorsmod.Register(ModuleName, 1138, "restart height cannot be negative") ) diff --git a/x/observer/types/genesis.pb.go b/x/observer/types/genesis.pb.go index 12d65ad082..e73bc3da52 100644 --- a/x/observer/types/genesis.pb.go +++ b/x/observer/types/genesis.pb.go @@ -40,6 +40,7 @@ type GenesisState struct { PendingNonces []PendingNonces `protobuf:"bytes,13,rep,name=pending_nonces,json=pendingNonces,proto3" json:"pending_nonces"` ChainNonces []ChainNonces `protobuf:"bytes,14,rep,name=chain_nonces,json=chainNonces,proto3" json:"chain_nonces"` NonceToCctx []NonceToCctx `protobuf:"bytes,15,rep,name=nonce_to_cctx,json=nonceToCctx,proto3" json:"nonce_to_cctx"` + OperationalFlags OperationalFlags `protobuf:"bytes,16,opt,name=operational_flags,json=operationalFlags,proto3" json:"operational_flags"` } func (m *GenesisState) Reset() { *m = GenesisState{} } @@ -180,6 +181,13 @@ func (m *GenesisState) GetNonceToCctx() []NonceToCctx { return nil } +func (m *GenesisState) GetOperationalFlags() OperationalFlags { + if m != nil { + return m.OperationalFlags + } + return OperationalFlags{} +} + func init() { proto.RegisterType((*GenesisState)(nil), "zetachain.zetacore.observer.GenesisState") } @@ -189,47 +197,50 @@ func init() { } var fileDescriptor_7679b0952a0823f4 = []byte{ - // 640 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xcf, 0x4e, 0x13, 0x41, - 0x1c, 0x6e, 0x05, 0x41, 0xa6, 0x40, 0x61, 0xf4, 0x30, 0xc1, 0x64, 0x25, 0x18, 0x63, 0x45, 0xdd, - 0x25, 0xd5, 0x9b, 0xf1, 0x20, 0x44, 0xd0, 0x88, 0xa8, 0x5b, 0x12, 0x13, 0x0f, 0x6c, 0xa6, 0xd3, - 0x61, 0xd9, 0xb8, 0x9d, 0x69, 0x76, 0xa6, 0x06, 0x7c, 0x0a, 0x9f, 0xc4, 0xe7, 0xe0, 0xc8, 0xd1, - 0x93, 0x31, 0xf4, 0x45, 0xcc, 0xfc, 0x6b, 0xbb, 0x3d, 0x0c, 0x7b, 0x9b, 0xfc, 0xe6, 0xfb, 0xbe, - 0x7c, 0xbf, 0xbf, 0xe0, 0xc9, 0x4f, 0x2a, 0x31, 0x39, 0xc3, 0x19, 0x8b, 0xf4, 0x8b, 0x17, 0x34, - 0xe2, 0x5d, 0x41, 0x8b, 0x1f, 0xb4, 0x88, 0x52, 0xca, 0xa8, 0xc8, 0x44, 0x38, 0x28, 0xb8, 0xe4, - 0xf0, 0xfe, 0x18, 0x1a, 0x3a, 0x68, 0xe8, 0xa0, 0x1b, 0xf7, 0x52, 0x9e, 0x72, 0x8d, 0x8b, 0xd4, - 0xcb, 0x50, 0x36, 0x5a, 0x3e, 0xf5, 0x2e, 0xce, 0x73, 0x2e, 0x2d, 0xf2, 0xb1, 0x17, 0x99, 0xe3, - 0x3e, 0xb5, 0xc0, 0xd0, 0x07, 0xd4, 0xf1, 0x84, 0x71, 0x46, 0xa8, 0x75, 0xbd, 0xd1, 0xf6, 0xe2, - 0x0b, 0x2e, 0x84, 0x21, 0x9d, 0xe6, 0x38, 0x15, 0x55, 0x6c, 0x7f, 0xa7, 0x17, 0x29, 0x65, 0x55, - 0xdc, 0x30, 0xde, 0xa3, 0x09, 0x26, 0x84, 0x0f, 0x99, 0x4b, 0x33, 0xf2, 0xe3, 0x19, 0xa1, 0x89, - 0xe4, 0x09, 0x21, 0xf2, 0xdc, 0x12, 0xb6, 0x7d, 0x04, 0xf7, 0xa8, 0x62, 0x7b, 0x80, 0x0b, 0xdc, - 0x77, 0x09, 0xee, 0x78, 0x91, 0x94, 0xf5, 0x32, 0x96, 0x96, 0xcb, 0xf8, 0xc8, 0xc7, 0x90, 0xc2, - 0xc1, 0x5e, 0xde, 0x00, 0x4b, 0x4e, 0x87, 0xac, 0x27, 0x92, 0x7e, 0x96, 0x16, 0x58, 0x72, 0x6b, - 0x7c, 0xeb, 0xf7, 0x12, 0x58, 0x3e, 0x30, 0xb3, 0xd6, 0x91, 0x58, 0x52, 0xf8, 0x1a, 0x2c, 0x9a, - 0xe9, 0x10, 0xa8, 0xbe, 0x39, 0xd7, 0x6a, 0xb4, 0x1f, 0x86, 0x9e, 0xe1, 0x0b, 0x77, 0x35, 0x36, - 0x76, 0x1c, 0x78, 0x08, 0x96, 0xdc, 0x9f, 0x40, 0xb7, 0x36, 0xeb, 0xad, 0x46, 0xbb, 0xe5, 0x15, - 0xf8, 0x64, 0x1f, 0x1d, 0x2a, 0x77, 0xe7, 0x2f, 0xff, 0x3e, 0xa8, 0xc5, 0x13, 0x01, 0x18, 0x83, - 0xa6, 0xea, 0xe4, 0x1b, 0xd3, 0xc8, 0xc3, 0x4c, 0x48, 0x34, 0xa7, 0x4d, 0xf9, 0x35, 0x8f, 0x26, - 0x9c, 0x78, 0x56, 0x00, 0x7e, 0x05, 0x6b, 0xb3, 0xb3, 0x87, 0xe6, 0xb5, 0xd1, 0x67, 0x5e, 0xd1, - 0xbd, 0x31, 0x69, 0x5f, 0x71, 0xe2, 0x26, 0x29, 0x07, 0xe0, 0x2b, 0xb0, 0x60, 0x3a, 0x8d, 0x6e, - 0x6b, 0x39, 0x7f, 0xe1, 0x3e, 0x6b, 0x68, 0x6c, 0x29, 0x8a, 0x6c, 0xa6, 0x1b, 0x2d, 0x54, 0x20, - 0x7f, 0xd0, 0xd0, 0xd8, 0x52, 0xe0, 0x09, 0xb8, 0x9b, 0x63, 0x21, 0x13, 0xf7, 0x9f, 0xe8, 0x6c, - 0xd1, 0xa2, 0x56, 0x0a, 0xbd, 0x4a, 0x87, 0x58, 0x48, 0xd7, 0x82, 0x3d, 0x5d, 0xb0, 0xf5, 0x7c, - 0x36, 0x04, 0x4f, 0xc0, 0xba, 0xa9, 0x96, 0x31, 0x9b, 0xe4, 0xaa, 0x11, 0x77, 0xaa, 0xd4, 0x4c, - 0xc5, 0x4d, 0xa6, 0xaa, 0xf6, 0xb6, 0xc1, 0x4d, 0x52, 0x0e, 0xc3, 0x36, 0x98, 0x93, 0x42, 0xa0, - 0x25, 0xad, 0xb8, 0xe9, 0x55, 0x3c, 0xee, 0x74, 0x62, 0x05, 0x86, 0x07, 0xa0, 0xa1, 0x86, 0xfa, - 0x2c, 0x13, 0x92, 0x17, 0x17, 0x08, 0xe8, 0xb1, 0xb8, 0x91, 0x6b, 0x1d, 0x00, 0x29, 0xc4, 0x3b, - 0xc3, 0x84, 0x3d, 0x00, 0xdd, 0x76, 0x8c, 0x97, 0x43, 0xa0, 0x86, 0xd6, 0xdb, 0xf1, 0xeb, 0x09, - 0xb1, 0x3f, 0x64, 0xbd, 0x8f, 0x96, 0xf4, 0x9e, 0x9d, 0x72, 0xab, 0xbf, 0x26, 0xcb, 0x5f, 0xca, - 0x2e, 0xd0, 0xa7, 0xd4, 0xd4, 0x6e, 0x59, 0xab, 0x6f, 0xf9, 0x37, 0x4b, 0xc1, 0xdd, 0x4a, 0x68, - 0xae, 0x1d, 0xdf, 0xd5, 0xf2, 0x95, 0x40, 0x2b, 0x5a, 0x6c, 0xdb, 0x3f, 0x6d, 0x86, 0x72, 0xa4, - 0x19, 0x56, 0x74, 0x65, 0x30, 0x1d, 0x84, 0x5f, 0xc0, 0xf2, 0xf4, 0x0d, 0x47, 0xab, 0x15, 0x16, - 0x4d, 0xf7, 0xb7, 0x24, 0xda, 0x20, 0x93, 0x10, 0x8c, 0xc1, 0x4a, 0xe9, 0xb0, 0xa2, 0x66, 0xa5, - 0xe5, 0x65, 0x84, 0x1e, 0xf3, 0x3d, 0x22, 0xcf, 0x9d, 0x26, 0x9b, 0x0a, 0xbd, 0xbd, 0xbc, 0x0e, - 0xea, 0x57, 0xd7, 0x41, 0xfd, 0xdf, 0x75, 0x50, 0xff, 0x35, 0x0a, 0x6a, 0x57, 0xa3, 0xa0, 0xf6, - 0x67, 0x14, 0xd4, 0xbe, 0x3d, 0x4d, 0x33, 0x79, 0x36, 0xec, 0x86, 0x84, 0xf7, 0xf5, 0x05, 0x7c, - 0x6e, 0x8e, 0xa1, 0xda, 0xff, 0xe8, 0x7c, 0xea, 0x14, 0x5e, 0x0c, 0xa8, 0xe8, 0x2e, 0xe8, 0xf3, - 0xf7, 0xe2, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x5f, 0xb9, 0x0b, 0x93, 0x85, 0x07, 0x00, 0x00, + // 673 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0x4f, 0x4f, 0x13, 0x41, + 0x1c, 0x6d, 0x05, 0x41, 0xa6, 0x40, 0x61, 0xf4, 0x30, 0xc1, 0xa4, 0x12, 0x8c, 0xb1, 0xa2, 0x6c, + 0x49, 0xf5, 0x66, 0x3c, 0x08, 0x11, 0x34, 0x22, 0xea, 0x96, 0xc4, 0xc4, 0x03, 0xeb, 0x74, 0x3a, + 0x2c, 0x1b, 0xb7, 0x33, 0xcd, 0xce, 0xd4, 0x80, 0x9f, 0x82, 0x8f, 0xc5, 0x91, 0xa3, 0x27, 0x63, + 0xe0, 0x8b, 0x98, 0xfd, 0xcd, 0x4c, 0xdb, 0xed, 0x61, 0xd8, 0xdb, 0xe4, 0x37, 0xef, 0xbd, 0xfc, + 0xfe, 0x3e, 0xf4, 0xec, 0x37, 0xd7, 0x94, 0x9d, 0xd2, 0x44, 0xb4, 0xe0, 0x25, 0x33, 0xde, 0x92, + 0x5d, 0xc5, 0xb3, 0x5f, 0x3c, 0x6b, 0xc5, 0x5c, 0x70, 0x95, 0xa8, 0x60, 0x90, 0x49, 0x2d, 0xf1, + 0xc3, 0x11, 0x34, 0x70, 0xd0, 0xc0, 0x41, 0xd7, 0x1e, 0xc4, 0x32, 0x96, 0x80, 0x6b, 0xe5, 0x2f, + 0x43, 0x59, 0x6b, 0xfa, 0xd4, 0xbb, 0x34, 0x4d, 0xa5, 0xb6, 0xc8, 0xa7, 0x5e, 0x64, 0x4a, 0xfb, + 0xdc, 0x02, 0x03, 0x1f, 0x10, 0xe2, 0x91, 0x90, 0x82, 0x71, 0x9b, 0xf5, 0x5a, 0xdb, 0x8b, 0xcf, + 0xa4, 0x52, 0x86, 0x74, 0x92, 0xd2, 0x58, 0x95, 0x49, 0xfb, 0x27, 0x3f, 0x8f, 0xb9, 0x28, 0x93, + 0x8d, 0x90, 0x3d, 0x1e, 0x51, 0xc6, 0xe4, 0x50, 0xb8, 0x32, 0x5b, 0x7e, 0xbc, 0x60, 0x3c, 0xd2, + 0x32, 0x62, 0x4c, 0x9f, 0x59, 0xc2, 0xa6, 0x8f, 0xe0, 0x1e, 0x65, 0xd2, 0x1e, 0xd0, 0x8c, 0xf6, + 0x5d, 0x81, 0xdb, 0x5e, 0x24, 0x17, 0xbd, 0x44, 0xc4, 0xc5, 0x36, 0x3e, 0xf1, 0x31, 0xb4, 0x72, + 0xb0, 0x57, 0xb7, 0xc0, 0xa2, 0x93, 0xa1, 0xe8, 0xa9, 0xa8, 0x9f, 0xc4, 0x19, 0xd5, 0xd2, 0x25, + 0xbe, 0xe5, 0x2d, 0x72, 0xc0, 0x33, 0xaa, 0x13, 0x29, 0x68, 0x6a, 0xe0, 0x1b, 0x17, 0x08, 0x2d, + 0xee, 0x9b, 0xd5, 0xec, 0x68, 0xaa, 0x39, 0x7e, 0x83, 0xe6, 0xcd, 0x32, 0x29, 0x52, 0x5d, 0x9f, + 0x69, 0xd6, 0xda, 0x8f, 0x03, 0xcf, 0xae, 0x06, 0x3b, 0x80, 0x0d, 0x1d, 0x07, 0x1f, 0xa0, 0x05, + 0xf7, 0xa7, 0xc8, 0x9d, 0xf5, 0x6a, 0xb3, 0xd6, 0x6e, 0x7a, 0x05, 0x3e, 0xdb, 0x47, 0x87, 0xeb, + 0x9d, 0xd9, 0xcb, 0xbf, 0x8f, 0x2a, 0xe1, 0x58, 0x00, 0x87, 0xa8, 0x9e, 0x0f, 0xfe, 0xad, 0x99, + 0xfb, 0x41, 0xa2, 0x34, 0x99, 0x81, 0xa4, 0xfc, 0x9a, 0x87, 0x63, 0x4e, 0x38, 0x2d, 0x80, 0xbf, + 0xa1, 0x95, 0xe9, 0x55, 0x25, 0xb3, 0x90, 0xe8, 0x0b, 0xaf, 0xe8, 0xee, 0x88, 0xb4, 0x97, 0x73, + 0xc2, 0x3a, 0x2b, 0x06, 0xf0, 0x6b, 0x34, 0x67, 0x16, 0x83, 0xdc, 0x05, 0x39, 0x7f, 0xe3, 0xbe, + 0x00, 0x34, 0xb4, 0x94, 0x9c, 0x6c, 0x8e, 0x81, 0xcc, 0x95, 0x20, 0x7f, 0x04, 0x68, 0x68, 0x29, + 0xf8, 0x18, 0xdd, 0x4f, 0xa9, 0xd2, 0x91, 0xfb, 0x8f, 0xa0, 0x5a, 0x32, 0x0f, 0x4a, 0x81, 0x57, + 0xe9, 0x80, 0x2a, 0xed, 0x46, 0xb0, 0x0b, 0x0d, 0x5b, 0x4d, 0xa7, 0x43, 0xf8, 0x18, 0xad, 0x9a, + 0x6e, 0x99, 0x64, 0xa3, 0x34, 0x1f, 0xc4, 0xbd, 0x32, 0x3d, 0xcb, 0xe3, 0xa6, 0xd2, 0xbc, 0xf7, + 0x76, 0xc0, 0x75, 0x56, 0x0c, 0xe3, 0x36, 0x9a, 0xd1, 0x4a, 0x91, 0x05, 0x50, 0x5c, 0xf7, 0x2a, + 0x1e, 0x75, 0x3a, 0x61, 0x0e, 0xc6, 0xfb, 0xa8, 0x96, 0xdf, 0xc0, 0x69, 0xa2, 0xb4, 0xcc, 0xce, + 0x09, 0x82, 0xb5, 0xb8, 0x95, 0x6b, 0x33, 0x40, 0x5a, 0xa9, 0xf7, 0x86, 0x89, 0x7b, 0x08, 0xbb, + 0x63, 0x1a, 0xdd, 0x92, 0x22, 0x35, 0xd0, 0xdb, 0xf6, 0xeb, 0x29, 0xb5, 0x37, 0x14, 0xbd, 0x4f, + 0x96, 0xf4, 0x41, 0x9c, 0x48, 0xab, 0xbf, 0xa2, 0x8b, 0x5f, 0x79, 0xba, 0x08, 0x9c, 0xd7, 0xf4, + 0x6e, 0x11, 0xd4, 0x37, 0xfc, 0x97, 0x95, 0xc3, 0xdd, 0x49, 0x00, 0xd7, 0xae, 0xef, 0x72, 0xd1, + 0x54, 0xc8, 0x12, 0x88, 0x6d, 0xfa, 0xb7, 0xcd, 0x50, 0x0e, 0x81, 0x61, 0x45, 0x97, 0x06, 0x93, + 0x41, 0xfc, 0x15, 0x2d, 0x4e, 0x5a, 0x3e, 0x59, 0x2e, 0x71, 0x68, 0x30, 0xdf, 0x82, 0x68, 0x8d, + 0x8d, 0x43, 0x38, 0x44, 0x4b, 0x05, 0x1f, 0x26, 0xf5, 0x52, 0xc7, 0x2b, 0x18, 0x3f, 0x92, 0xbb, + 0x4c, 0x9f, 0x39, 0x4d, 0x31, 0x0e, 0xe1, 0x1f, 0x68, 0x75, 0xc2, 0xc5, 0xec, 0xfd, 0xae, 0xc0, + 0xe6, 0x6c, 0xf9, 0x8d, 0x66, 0xcc, 0x82, 0x7b, 0x75, 0xa3, 0x92, 0xd3, 0xf1, 0x77, 0x97, 0xd7, + 0x8d, 0xea, 0xd5, 0x75, 0xa3, 0xfa, 0xef, 0xba, 0x51, 0xbd, 0xb8, 0x69, 0x54, 0xae, 0x6e, 0x1a, + 0x95, 0x3f, 0x37, 0x8d, 0xca, 0xf7, 0xe7, 0x71, 0xa2, 0x4f, 0x87, 0xdd, 0x80, 0xc9, 0x3e, 0x98, + 0xeb, 0x96, 0xf1, 0xd9, 0xdc, 0x61, 0x5a, 0x67, 0x13, 0xde, 0x7c, 0x3e, 0xe0, 0xaa, 0x3b, 0x07, + 0x06, 0xfb, 0xf2, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xb3, 0xd7, 0x9f, 0xa0, 0x16, 0x08, 0x00, + 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { @@ -252,6 +263,18 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + { + size, err := m.OperationalFlags.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 if len(m.NonceToCctx) > 0 { for iNdEx := len(m.NonceToCctx) - 1; iNdEx >= 0; iNdEx-- { { @@ -536,6 +559,8 @@ func (m *GenesisState) Size() (n int) { n += 1 + l + sovGenesis(uint64(l)) } } + l = m.OperationalFlags.Size() + n += 2 + l + sovGenesis(uint64(l)) return n } @@ -1092,6 +1117,39 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OperationalFlags", 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.OperationalFlags.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenesis(dAtA[iNdEx:]) diff --git a/x/observer/types/keys.go b/x/observer/types/keys.go index abdb2543d0..ed57b13d79 100644 --- a/x/observer/types/keys.go +++ b/x/observer/types/keys.go @@ -87,6 +87,8 @@ const ( NonceToCctxKeyPrefix = "NonceToCctx-value-" ParamsKey = "Params-value-" + + OperationalFlagsKey = "OperationalFlags-value-" ) func GetBlameIndex(chainID int64, nonce uint64, digest string, height uint64) string { diff --git a/x/observer/types/message_update_operational_flags.go b/x/observer/types/message_update_operational_flags.go new file mode 100644 index 0000000000..021755485b --- /dev/null +++ b/x/observer/types/message_update_operational_flags.go @@ -0,0 +1,53 @@ +package types + +import ( + cosmoserrors "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" +) + +const ( + TypeMsgUpdateOperationalFlags = "update_operational_flags" +) + +var _ sdk.Msg = &MsgUpdateOperationalFlags{} + +func NewMsgUpdateOperationalFlags(creator string, flags OperationalFlags) *MsgUpdateOperationalFlags { + return &MsgUpdateOperationalFlags{ + Creator: creator, + OperationalFlags: flags, + } +} + +func (msg *MsgUpdateOperationalFlags) Route() string { + return RouterKey +} + +func (msg *MsgUpdateOperationalFlags) Type() string { + return TypeMsgUpdateOperationalFlags +} + +func (msg *MsgUpdateOperationalFlags) GetSigners() []sdk.AccAddress { + creator, err := sdk.AccAddressFromBech32(msg.Creator) + if err != nil { + panic(err) + } + return []sdk.AccAddress{creator} +} + +func (msg *MsgUpdateOperationalFlags) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +func (msg *MsgUpdateOperationalFlags) ValidateBasic() error { + if _, err := sdk.AccAddressFromBech32(msg.Creator); err != nil { + return cosmoserrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + } + + if err := msg.OperationalFlags.Validate(); err != nil { + return cosmoserrors.Wrap(sdkerrors.ErrInvalidRequest, err.Error()) + } + + return nil +} diff --git a/x/observer/types/message_update_operational_flags_test.go b/x/observer/types/message_update_operational_flags_test.go new file mode 100644 index 0000000000..6e38837e70 --- /dev/null +++ b/x/observer/types/message_update_operational_flags_test.go @@ -0,0 +1,109 @@ +package types_test + +import ( + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/require" + + "github.com/zeta-chain/node/testutil/sample" + "github.com/zeta-chain/node/x/observer/types" +) + +func TestMsgUpdateOperationalFlags_ValidateBasic(t *testing.T) { + tt := []struct { + name string + msg *types.MsgUpdateOperationalFlags + err require.ErrorAssertionFunc + }{ + { + name: "invalid creator address", + msg: types.NewMsgUpdateOperationalFlags("invalid", types.OperationalFlags{}), + err: func(t require.TestingT, err error, i ...interface{}) { + require.ErrorContains(t, err, "invalid creator address") + }, + }, + { + name: "invalid operational flags", + msg: types.NewMsgUpdateOperationalFlags( + sample.AccAddress(), + types.OperationalFlags{ + RestartHeight: -1, + }, + ), + err: func(t require.TestingT, err error, i ...interface{}) { + require.ErrorContains(t, err, "invalid request") + }, + }, + { + name: "valid", + msg: types.NewMsgUpdateOperationalFlags(sample.AccAddress(), sample.OperationalFlags()), + err: require.NoError, + }, + } + for _, tc := range tt { + t.Run(tc.name, func(t *testing.T) { + tc.err(t, tc.msg.ValidateBasic()) + }) + } +} + +func TestMsgUpdateOperationalFlags_GetSigners(t *testing.T) { + signer := sample.AccAddress() + tests := []struct { + name string + msg types.MsgUpdateOperationalFlags + panics bool + }{ + { + name: "valid signer", + msg: types.MsgUpdateOperationalFlags{ + Creator: signer, + }, + panics: false, + }, + { + name: "invalid signer", + msg: types.MsgUpdateOperationalFlags{ + Creator: "invalid", + }, + panics: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if !tt.panics { + signers := tt.msg.GetSigners() + require.Equal(t, []sdk.AccAddress{sdk.MustAccAddressFromBech32(signer)}, signers) + } else { + require.Panics(t, func() { + tt.msg.GetSigners() + }) + } + }) + } +} + +func TestMsgUpdateOperationalFlags_Type(t *testing.T) { + msg := types.MsgUpdateOperationalFlags{ + Creator: sample.AccAddress(), + } + require.Equal(t, types.TypeMsgUpdateOperationalFlags, msg.Type()) +} + +func TestMsgUpdateOperationalFlags_Route(t *testing.T) { + msg := types.MsgUpdateOperationalFlags{ + Creator: sample.AccAddress(), + } + require.Equal(t, types.RouterKey, msg.Route()) +} + +func TestMsgUpdateOperationalFlags_GetSignBytes(t *testing.T) { + msg := types.MsgUpdateOperationalFlags{ + Creator: sample.AccAddress(), + } + require.NotPanics(t, func() { + msg.GetSignBytes() + }) +} diff --git a/x/observer/types/operational.go b/x/observer/types/operational.go new file mode 100644 index 0000000000..2a4be035f6 --- /dev/null +++ b/x/observer/types/operational.go @@ -0,0 +1,8 @@ +package types + +func (f *OperationalFlags) Validate() error { + if f.RestartHeight < 0 { + return ErrOperationalFlagsRestartHeightNegative + } + return nil +} diff --git a/x/observer/types/operational.pb.go b/x/observer/types/operational.pb.go new file mode 100644 index 0000000000..b7af5711cf --- /dev/null +++ b/x/observer/types/operational.pb.go @@ -0,0 +1,305 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: zetachain/zetacore/observer/operational.proto + +package types + +import ( + fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// Flags for the top-level operation of zetaclient. +type OperationalFlags struct { + // Height for a coordinated zetaclient restart. + // Will be ignored if missed. + RestartHeight int64 `protobuf:"varint,1,opt,name=restart_height,json=restartHeight,proto3" json:"restart_height,omitempty"` +} + +func (m *OperationalFlags) Reset() { *m = OperationalFlags{} } +func (m *OperationalFlags) String() string { return proto.CompactTextString(m) } +func (*OperationalFlags) ProtoMessage() {} +func (*OperationalFlags) Descriptor() ([]byte, []int) { + return fileDescriptor_ea3eed2ec55093b5, []int{0} +} +func (m *OperationalFlags) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *OperationalFlags) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_OperationalFlags.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 *OperationalFlags) XXX_Merge(src proto.Message) { + xxx_messageInfo_OperationalFlags.Merge(m, src) +} +func (m *OperationalFlags) XXX_Size() int { + return m.Size() +} +func (m *OperationalFlags) XXX_DiscardUnknown() { + xxx_messageInfo_OperationalFlags.DiscardUnknown(m) +} + +var xxx_messageInfo_OperationalFlags proto.InternalMessageInfo + +func (m *OperationalFlags) GetRestartHeight() int64 { + if m != nil { + return m.RestartHeight + } + return 0 +} + +func init() { + proto.RegisterType((*OperationalFlags)(nil), "zetachain.zetacore.observer.OperationalFlags") +} + +func init() { + proto.RegisterFile("zetachain/zetacore/observer/operational.proto", fileDescriptor_ea3eed2ec55093b5) +} + +var fileDescriptor_ea3eed2ec55093b5 = []byte{ + // 184 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0xad, 0x4a, 0x2d, 0x49, + 0x4c, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x07, 0xb3, 0xf2, 0x8b, 0x52, 0xf5, 0xf3, 0x93, 0x8a, 0x53, + 0x8b, 0xca, 0x52, 0x8b, 0xf4, 0xf3, 0x0b, 0x52, 0x8b, 0x12, 0x4b, 0x32, 0xf3, 0xf3, 0x12, 0x73, + 0xf4, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0xa4, 0xe1, 0xca, 0xf5, 0x60, 0xca, 0xf5, 0x60, 0xca, + 0x95, 0x2c, 0xb9, 0x04, 0xfc, 0x11, 0x3a, 0xdc, 0x72, 0x12, 0xd3, 0x8b, 0x85, 0x54, 0xb9, 0xf8, + 0x8a, 0x52, 0x8b, 0x4b, 0x12, 0x8b, 0x4a, 0xe2, 0x33, 0x52, 0x33, 0xd3, 0x33, 0x4a, 0x24, 0x18, + 0x15, 0x18, 0x35, 0x98, 0x83, 0x78, 0xa1, 0xa2, 0x1e, 0x60, 0x41, 0x27, 0xd7, 0x13, 0x8f, 0xe4, + 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, 0x0b, 0x8f, + 0xe5, 0x18, 0x6e, 0x3c, 0x96, 0x63, 0x88, 0xd2, 0x4e, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, + 0xce, 0xcf, 0x05, 0xbb, 0x50, 0x17, 0xe2, 0xd8, 0xbc, 0xfc, 0x94, 0x54, 0xfd, 0x0a, 0x84, 0x53, + 0x4b, 0x2a, 0x0b, 0x52, 0x8b, 0x93, 0xd8, 0xc0, 0xae, 0x34, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, + 0xcf, 0xd8, 0x7d, 0x54, 0xd6, 0x00, 0x00, 0x00, +} + +func (m *OperationalFlags) 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 *OperationalFlags) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OperationalFlags) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.RestartHeight != 0 { + i = encodeVarintOperational(dAtA, i, uint64(m.RestartHeight)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintOperational(dAtA []byte, offset int, v uint64) int { + offset -= sovOperational(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *OperationalFlags) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RestartHeight != 0 { + n += 1 + sovOperational(uint64(m.RestartHeight)) + } + return n +} + +func sovOperational(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozOperational(x uint64) (n int) { + return sovOperational(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *OperationalFlags) 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 ErrIntOverflowOperational + } + 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: OperationalFlags: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OperationalFlags: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RestartHeight", wireType) + } + m.RestartHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOperational + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RestartHeight |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipOperational(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthOperational + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipOperational(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOperational + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOperational + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOperational + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthOperational + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupOperational + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthOperational + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthOperational = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowOperational = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupOperational = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/observer/types/operational_test.go b/x/observer/types/operational_test.go new file mode 100644 index 0000000000..39ef06ef82 --- /dev/null +++ b/x/observer/types/operational_test.go @@ -0,0 +1,40 @@ +package types_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + "github.com/zeta-chain/node/x/observer/types" +) + +func TestOperationalFlags_Validate(t *testing.T) { + tests := []struct { + name string + of types.OperationalFlags + errContains string + }{ + { + name: "invalid operational flags", + of: types.OperationalFlags{ + RestartHeight: -1, + }, + errContains: types.ErrOperationalFlagsRestartHeightNegative.Error(), + }, + { + name: "valid", + of: types.OperationalFlags{ + RestartHeight: 1, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := tt.of.Validate() + if tt.errContains != "" { + require.ErrorContains(t, err, tt.errContains) + return + } + require.NoError(t, err) + }) + } +} diff --git a/x/observer/types/query.pb.go b/x/observer/types/query.pb.go index 4f0216d03c..d9d7fe4397 100644 --- a/x/observer/types/query.pb.go +++ b/x/observer/types/query.pb.go @@ -32,6 +32,86 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package +type QueryOperationalFlagsRequest struct { +} + +func (m *QueryOperationalFlagsRequest) Reset() { *m = QueryOperationalFlagsRequest{} } +func (m *QueryOperationalFlagsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryOperationalFlagsRequest) ProtoMessage() {} +func (*QueryOperationalFlagsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_25b2aa420449a0c0, []int{0} +} +func (m *QueryOperationalFlagsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryOperationalFlagsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryOperationalFlagsRequest.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 *QueryOperationalFlagsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryOperationalFlagsRequest.Merge(m, src) +} +func (m *QueryOperationalFlagsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryOperationalFlagsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryOperationalFlagsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryOperationalFlagsRequest proto.InternalMessageInfo + +type QueryOperationalFlagsResponse struct { + OperationalFlags OperationalFlags `protobuf:"bytes,1,opt,name=operational_flags,json=operationalFlags,proto3" json:"operational_flags"` +} + +func (m *QueryOperationalFlagsResponse) Reset() { *m = QueryOperationalFlagsResponse{} } +func (m *QueryOperationalFlagsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryOperationalFlagsResponse) ProtoMessage() {} +func (*QueryOperationalFlagsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_25b2aa420449a0c0, []int{1} +} +func (m *QueryOperationalFlagsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryOperationalFlagsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryOperationalFlagsResponse.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 *QueryOperationalFlagsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryOperationalFlagsResponse.Merge(m, src) +} +func (m *QueryOperationalFlagsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryOperationalFlagsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryOperationalFlagsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryOperationalFlagsResponse proto.InternalMessageInfo + +func (m *QueryOperationalFlagsResponse) GetOperationalFlags() OperationalFlags { + if m != nil { + return m.OperationalFlags + } + return OperationalFlags{} +} + type QueryTssFundsMigratorInfoAllRequest struct { } @@ -39,7 +119,7 @@ func (m *QueryTssFundsMigratorInfoAllRequest) Reset() { *m = QueryTssFun func (m *QueryTssFundsMigratorInfoAllRequest) String() string { return proto.CompactTextString(m) } func (*QueryTssFundsMigratorInfoAllRequest) ProtoMessage() {} func (*QueryTssFundsMigratorInfoAllRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{0} + return fileDescriptor_25b2aa420449a0c0, []int{2} } func (m *QueryTssFundsMigratorInfoAllRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -76,7 +156,7 @@ func (m *QueryTssFundsMigratorInfoAllResponse) Reset() { *m = QueryTssFu func (m *QueryTssFundsMigratorInfoAllResponse) String() string { return proto.CompactTextString(m) } func (*QueryTssFundsMigratorInfoAllResponse) ProtoMessage() {} func (*QueryTssFundsMigratorInfoAllResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{1} + return fileDescriptor_25b2aa420449a0c0, []int{3} } func (m *QueryTssFundsMigratorInfoAllResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -120,7 +200,7 @@ func (m *QueryTssFundsMigratorInfoRequest) Reset() { *m = QueryTssFundsM func (m *QueryTssFundsMigratorInfoRequest) String() string { return proto.CompactTextString(m) } func (*QueryTssFundsMigratorInfoRequest) ProtoMessage() {} func (*QueryTssFundsMigratorInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{2} + return fileDescriptor_25b2aa420449a0c0, []int{4} } func (m *QueryTssFundsMigratorInfoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -164,7 +244,7 @@ func (m *QueryTssFundsMigratorInfoResponse) Reset() { *m = QueryTssFunds func (m *QueryTssFundsMigratorInfoResponse) String() string { return proto.CompactTextString(m) } func (*QueryTssFundsMigratorInfoResponse) ProtoMessage() {} func (*QueryTssFundsMigratorInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{3} + return fileDescriptor_25b2aa420449a0c0, []int{5} } func (m *QueryTssFundsMigratorInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -208,7 +288,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_25b2aa420449a0c0, []int{4} + return fileDescriptor_25b2aa420449a0c0, []int{6} } func (m *QueryGetChainNoncesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -252,7 +332,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_25b2aa420449a0c0, []int{5} + return fileDescriptor_25b2aa420449a0c0, []int{7} } func (m *QueryGetChainNoncesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -296,7 +376,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_25b2aa420449a0c0, []int{6} + return fileDescriptor_25b2aa420449a0c0, []int{8} } func (m *QueryAllChainNoncesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -341,7 +421,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_25b2aa420449a0c0, []int{7} + return fileDescriptor_25b2aa420449a0c0, []int{9} } func (m *QueryAllChainNoncesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -392,7 +472,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_25b2aa420449a0c0, []int{8} + return fileDescriptor_25b2aa420449a0c0, []int{10} } func (m *QueryAllPendingNoncesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -437,7 +517,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_25b2aa420449a0c0, []int{9} + return fileDescriptor_25b2aa420449a0c0, []int{11} } func (m *QueryAllPendingNoncesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -488,7 +568,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_25b2aa420449a0c0, []int{10} + return fileDescriptor_25b2aa420449a0c0, []int{12} } func (m *QueryPendingNoncesByChainRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -532,7 +612,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_25b2aa420449a0c0, []int{11} + return fileDescriptor_25b2aa420449a0c0, []int{13} } func (m *QueryPendingNoncesByChainResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -575,7 +655,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_25b2aa420449a0c0, []int{12} + return fileDescriptor_25b2aa420449a0c0, []int{14} } func (m *QueryGetTSSRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -612,7 +692,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_25b2aa420449a0c0, []int{13} + return fileDescriptor_25b2aa420449a0c0, []int{15} } func (m *QueryGetTSSResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -656,7 +736,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_25b2aa420449a0c0, []int{14} + return fileDescriptor_25b2aa420449a0c0, []int{16} } func (m *QueryGetTssAddressRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -701,7 +781,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_25b2aa420449a0c0, []int{15} + return fileDescriptor_25b2aa420449a0c0, []int{17} } func (m *QueryGetTssAddressResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -757,7 +837,7 @@ func (m *QueryGetTssAddressByFinalizedHeightRequest) String() string { } func (*QueryGetTssAddressByFinalizedHeightRequest) ProtoMessage() {} func (*QueryGetTssAddressByFinalizedHeightRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{16} + return fileDescriptor_25b2aa420449a0c0, []int{18} } func (m *QueryGetTssAddressByFinalizedHeightRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -813,7 +893,7 @@ func (m *QueryGetTssAddressByFinalizedHeightResponse) String() string { } func (*QueryGetTssAddressByFinalizedHeightResponse) ProtoMessage() {} func (*QueryGetTssAddressByFinalizedHeightResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{17} + return fileDescriptor_25b2aa420449a0c0, []int{19} } func (m *QueryGetTssAddressByFinalizedHeightResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -864,7 +944,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_25b2aa420449a0c0, []int{18} + return fileDescriptor_25b2aa420449a0c0, []int{20} } func (m *QueryTssHistoryRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -909,7 +989,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_25b2aa420449a0c0, []int{19} + return fileDescriptor_25b2aa420449a0c0, []int{21} } func (m *QueryTssHistoryResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -961,7 +1041,7 @@ func (m *QueryHasVotedRequest) Reset() { *m = QueryHasVotedRequest{} } func (m *QueryHasVotedRequest) String() string { return proto.CompactTextString(m) } func (*QueryHasVotedRequest) ProtoMessage() {} func (*QueryHasVotedRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{20} + return fileDescriptor_25b2aa420449a0c0, []int{22} } func (m *QueryHasVotedRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1012,7 +1092,7 @@ func (m *QueryHasVotedResponse) Reset() { *m = QueryHasVotedResponse{} } func (m *QueryHasVotedResponse) String() string { return proto.CompactTextString(m) } func (*QueryHasVotedResponse) ProtoMessage() {} func (*QueryHasVotedResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{21} + return fileDescriptor_25b2aa420449a0c0, []int{23} } func (m *QueryHasVotedResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1056,7 +1136,7 @@ func (m *QueryBallotByIdentifierRequest) Reset() { *m = QueryBallotByIde func (m *QueryBallotByIdentifierRequest) String() string { return proto.CompactTextString(m) } func (*QueryBallotByIdentifierRequest) ProtoMessage() {} func (*QueryBallotByIdentifierRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{22} + return fileDescriptor_25b2aa420449a0c0, []int{24} } func (m *QueryBallotByIdentifierRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1101,7 +1181,7 @@ func (m *VoterList) Reset() { *m = VoterList{} } func (m *VoterList) String() string { return proto.CompactTextString(m) } func (*VoterList) ProtoMessage() {} func (*VoterList) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{23} + return fileDescriptor_25b2aa420449a0c0, []int{25} } func (m *VoterList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1155,7 +1235,7 @@ func (m *QueryBallotByIdentifierResponse) Reset() { *m = QueryBallotById func (m *QueryBallotByIdentifierResponse) String() string { return proto.CompactTextString(m) } func (*QueryBallotByIdentifierResponse) ProtoMessage() {} func (*QueryBallotByIdentifierResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{24} + return fileDescriptor_25b2aa420449a0c0, []int{26} } func (m *QueryBallotByIdentifierResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1219,7 +1299,7 @@ func (m *QueryObserverSet) Reset() { *m = QueryObserverSet{} } func (m *QueryObserverSet) String() string { return proto.CompactTextString(m) } func (*QueryObserverSet) ProtoMessage() {} func (*QueryObserverSet) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{25} + return fileDescriptor_25b2aa420449a0c0, []int{27} } func (m *QueryObserverSet) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1256,7 +1336,7 @@ func (m *QueryObserverSetResponse) Reset() { *m = QueryObserverSetRespon func (m *QueryObserverSetResponse) String() string { return proto.CompactTextString(m) } func (*QueryObserverSetResponse) ProtoMessage() {} func (*QueryObserverSetResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{26} + return fileDescriptor_25b2aa420449a0c0, []int{28} } func (m *QueryObserverSetResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1299,7 +1379,7 @@ func (m *QuerySupportedChains) Reset() { *m = QuerySupportedChains{} } func (m *QuerySupportedChains) String() string { return proto.CompactTextString(m) } func (*QuerySupportedChains) ProtoMessage() {} func (*QuerySupportedChains) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{27} + return fileDescriptor_25b2aa420449a0c0, []int{29} } func (m *QuerySupportedChains) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1336,7 +1416,7 @@ func (m *QuerySupportedChainsResponse) Reset() { *m = QuerySupportedChai func (m *QuerySupportedChainsResponse) String() string { return proto.CompactTextString(m) } func (*QuerySupportedChainsResponse) ProtoMessage() {} func (*QuerySupportedChainsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{28} + return fileDescriptor_25b2aa420449a0c0, []int{30} } func (m *QuerySupportedChainsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1380,7 +1460,7 @@ func (m *QueryGetChainParamsForChainRequest) Reset() { *m = QueryGetChai func (m *QueryGetChainParamsForChainRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetChainParamsForChainRequest) ProtoMessage() {} func (*QueryGetChainParamsForChainRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{29} + return fileDescriptor_25b2aa420449a0c0, []int{31} } func (m *QueryGetChainParamsForChainRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1424,7 +1504,7 @@ func (m *QueryGetChainParamsForChainResponse) Reset() { *m = QueryGetCha func (m *QueryGetChainParamsForChainResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetChainParamsForChainResponse) ProtoMessage() {} func (*QueryGetChainParamsForChainResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{30} + return fileDescriptor_25b2aa420449a0c0, []int{32} } func (m *QueryGetChainParamsForChainResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1467,7 +1547,7 @@ func (m *QueryGetChainParamsRequest) Reset() { *m = QueryGetChainParamsR func (m *QueryGetChainParamsRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetChainParamsRequest) ProtoMessage() {} func (*QueryGetChainParamsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{31} + return fileDescriptor_25b2aa420449a0c0, []int{33} } func (m *QueryGetChainParamsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1504,7 +1584,7 @@ func (m *QueryGetChainParamsResponse) Reset() { *m = QueryGetChainParams func (m *QueryGetChainParamsResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetChainParamsResponse) ProtoMessage() {} func (*QueryGetChainParamsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{32} + return fileDescriptor_25b2aa420449a0c0, []int{34} } func (m *QueryGetChainParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1548,7 +1628,7 @@ func (m *QueryGetNodeAccountRequest) Reset() { *m = QueryGetNodeAccountR func (m *QueryGetNodeAccountRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetNodeAccountRequest) ProtoMessage() {} func (*QueryGetNodeAccountRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{33} + return fileDescriptor_25b2aa420449a0c0, []int{35} } func (m *QueryGetNodeAccountRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1592,7 +1672,7 @@ func (m *QueryGetNodeAccountResponse) Reset() { *m = QueryGetNodeAccount func (m *QueryGetNodeAccountResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetNodeAccountResponse) ProtoMessage() {} func (*QueryGetNodeAccountResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{34} + return fileDescriptor_25b2aa420449a0c0, []int{36} } func (m *QueryGetNodeAccountResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1636,7 +1716,7 @@ func (m *QueryAllNodeAccountRequest) Reset() { *m = QueryAllNodeAccountR func (m *QueryAllNodeAccountRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllNodeAccountRequest) ProtoMessage() {} func (*QueryAllNodeAccountRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{35} + return fileDescriptor_25b2aa420449a0c0, []int{37} } func (m *QueryAllNodeAccountRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1681,7 +1761,7 @@ func (m *QueryAllNodeAccountResponse) Reset() { *m = QueryAllNodeAccount func (m *QueryAllNodeAccountResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllNodeAccountResponse) ProtoMessage() {} func (*QueryAllNodeAccountResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{36} + return fileDescriptor_25b2aa420449a0c0, []int{38} } func (m *QueryAllNodeAccountResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1731,7 +1811,7 @@ func (m *QueryGetCrosschainFlagsRequest) Reset() { *m = QueryGetCrosscha func (m *QueryGetCrosschainFlagsRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetCrosschainFlagsRequest) ProtoMessage() {} func (*QueryGetCrosschainFlagsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{37} + return fileDescriptor_25b2aa420449a0c0, []int{39} } func (m *QueryGetCrosschainFlagsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1768,7 +1848,7 @@ func (m *QueryGetCrosschainFlagsResponse) Reset() { *m = QueryGetCrossch func (m *QueryGetCrosschainFlagsResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetCrosschainFlagsResponse) ProtoMessage() {} func (*QueryGetCrosschainFlagsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{38} + return fileDescriptor_25b2aa420449a0c0, []int{40} } func (m *QueryGetCrosschainFlagsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1811,7 +1891,7 @@ func (m *QueryGetKeygenRequest) Reset() { *m = QueryGetKeygenRequest{} } func (m *QueryGetKeygenRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetKeygenRequest) ProtoMessage() {} func (*QueryGetKeygenRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{39} + return fileDescriptor_25b2aa420449a0c0, []int{41} } func (m *QueryGetKeygenRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1848,7 +1928,7 @@ func (m *QueryGetKeygenResponse) Reset() { *m = QueryGetKeygenResponse{} func (m *QueryGetKeygenResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetKeygenResponse) ProtoMessage() {} func (*QueryGetKeygenResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{40} + return fileDescriptor_25b2aa420449a0c0, []int{42} } func (m *QueryGetKeygenResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1891,7 +1971,7 @@ func (m *QueryShowObserverCountRequest) Reset() { *m = QueryShowObserver func (m *QueryShowObserverCountRequest) String() string { return proto.CompactTextString(m) } func (*QueryShowObserverCountRequest) ProtoMessage() {} func (*QueryShowObserverCountRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{41} + return fileDescriptor_25b2aa420449a0c0, []int{43} } func (m *QueryShowObserverCountRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1928,7 +2008,7 @@ func (m *QueryShowObserverCountResponse) Reset() { *m = QueryShowObserve func (m *QueryShowObserverCountResponse) String() string { return proto.CompactTextString(m) } func (*QueryShowObserverCountResponse) ProtoMessage() {} func (*QueryShowObserverCountResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{42} + return fileDescriptor_25b2aa420449a0c0, []int{44} } func (m *QueryShowObserverCountResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1972,7 +2052,7 @@ func (m *QueryBlameByIdentifierRequest) Reset() { *m = QueryBlameByIdent func (m *QueryBlameByIdentifierRequest) String() string { return proto.CompactTextString(m) } func (*QueryBlameByIdentifierRequest) ProtoMessage() {} func (*QueryBlameByIdentifierRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{43} + return fileDescriptor_25b2aa420449a0c0, []int{45} } func (m *QueryBlameByIdentifierRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2016,7 +2096,7 @@ func (m *QueryBlameByIdentifierResponse) Reset() { *m = QueryBlameByIden func (m *QueryBlameByIdentifierResponse) String() string { return proto.CompactTextString(m) } func (*QueryBlameByIdentifierResponse) ProtoMessage() {} func (*QueryBlameByIdentifierResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{44} + return fileDescriptor_25b2aa420449a0c0, []int{46} } func (m *QueryBlameByIdentifierResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2060,7 +2140,7 @@ func (m *QueryAllBlameRecordsRequest) Reset() { *m = QueryAllBlameRecord func (m *QueryAllBlameRecordsRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllBlameRecordsRequest) ProtoMessage() {} func (*QueryAllBlameRecordsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{45} + return fileDescriptor_25b2aa420449a0c0, []int{47} } func (m *QueryAllBlameRecordsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2105,7 +2185,7 @@ func (m *QueryAllBlameRecordsResponse) Reset() { *m = QueryAllBlameRecor func (m *QueryAllBlameRecordsResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllBlameRecordsResponse) ProtoMessage() {} func (*QueryAllBlameRecordsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{46} + return fileDescriptor_25b2aa420449a0c0, []int{48} } func (m *QueryAllBlameRecordsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2157,7 +2237,7 @@ func (m *QueryBlameByChainAndNonceRequest) Reset() { *m = QueryBlameByCh func (m *QueryBlameByChainAndNonceRequest) String() string { return proto.CompactTextString(m) } func (*QueryBlameByChainAndNonceRequest) ProtoMessage() {} func (*QueryBlameByChainAndNonceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{47} + return fileDescriptor_25b2aa420449a0c0, []int{49} } func (m *QueryBlameByChainAndNonceRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2208,7 +2288,7 @@ func (m *QueryBlameByChainAndNonceResponse) Reset() { *m = QueryBlameByC func (m *QueryBlameByChainAndNonceResponse) String() string { return proto.CompactTextString(m) } func (*QueryBlameByChainAndNonceResponse) ProtoMessage() {} func (*QueryBlameByChainAndNonceResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_25b2aa420449a0c0, []int{48} + return fileDescriptor_25b2aa420449a0c0, []int{50} } func (m *QueryBlameByChainAndNonceResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2245,6 +2325,8 @@ func (m *QueryBlameByChainAndNonceResponse) GetBlameInfo() []*Blame { } func init() { + proto.RegisterType((*QueryOperationalFlagsRequest)(nil), "zetachain.zetacore.observer.QueryOperationalFlagsRequest") + proto.RegisterType((*QueryOperationalFlagsResponse)(nil), "zetachain.zetacore.observer.QueryOperationalFlagsResponse") proto.RegisterType((*QueryTssFundsMigratorInfoAllRequest)(nil), "zetachain.zetacore.observer.QueryTssFundsMigratorInfoAllRequest") proto.RegisterType((*QueryTssFundsMigratorInfoAllResponse)(nil), "zetachain.zetacore.observer.QueryTssFundsMigratorInfoAllResponse") proto.RegisterType((*QueryTssFundsMigratorInfoRequest)(nil), "zetachain.zetacore.observer.QueryTssFundsMigratorInfoRequest") @@ -2301,151 +2383,156 @@ func init() { } var fileDescriptor_25b2aa420449a0c0 = []byte{ - // 2300 bytes of a gzipped FileDescriptorProto + // 2374 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x5a, 0xcf, 0x6f, 0x1b, 0xc7, - 0x15, 0xf6, 0x4a, 0x89, 0x22, 0x8d, 0x6c, 0xfd, 0x18, 0xcb, 0xb6, 0x42, 0x3b, 0xb2, 0xbc, 0x92, - 0x63, 0x59, 0x96, 0xb8, 0xb6, 0xec, 0xd4, 0xbf, 0xe2, 0xd8, 0xa2, 0x6b, 0x49, 0x76, 0x12, 0xdb, - 0x21, 0xdd, 0x06, 0x30, 0xda, 0xb2, 0x4b, 0xee, 0x90, 0xdc, 0x7a, 0xb5, 0xc3, 0xec, 0x8c, 0x9c, - 0x30, 0xaa, 0x80, 0xa2, 0xb7, 0xe6, 0x50, 0x14, 0x28, 0xd0, 0xde, 0x8a, 0x02, 0x45, 0x8f, 0x05, - 0x8a, 0x00, 0x41, 0x0b, 0x14, 0x3d, 0xe4, 0xd4, 0x1c, 0x7a, 0x48, 0xd1, 0xa2, 0xe8, 0xa9, 0x35, - 0xec, 0xfe, 0x21, 0xc5, 0xce, 0xbc, 0x25, 0x77, 0x97, 0xbb, 0xcb, 0x21, 0xad, 0x9e, 0xc8, 0x9d, - 0x99, 0xf7, 0xe6, 0xfb, 0xde, 0xce, 0xbc, 0xf9, 0x66, 0x66, 0xd1, 0x99, 0x4f, 0x09, 0x37, 0xab, - 0x0d, 0xd3, 0x76, 0x0d, 0xf1, 0x8f, 0x7a, 0xc4, 0xa0, 0x15, 0x46, 0xbc, 0xa7, 0xc4, 0x33, 0x3e, - 0xda, 0x21, 0x5e, 0x2b, 0xdf, 0xf4, 0x28, 0xa7, 0xf8, 0x78, 0xbb, 0x61, 0x3e, 0x68, 0x98, 0x0f, - 0x1a, 0xe6, 0x96, 0xab, 0x94, 0x6d, 0x53, 0x66, 0x54, 0x4c, 0x46, 0xa4, 0x95, 0xf1, 0xf4, 0x42, - 0x85, 0x70, 0xf3, 0x82, 0xd1, 0x34, 0xeb, 0xb6, 0x6b, 0x72, 0x9b, 0xba, 0xd2, 0x51, 0x6e, 0xa6, - 0x4e, 0xeb, 0x54, 0xfc, 0x35, 0xfc, 0x7f, 0x50, 0x7a, 0xa2, 0x4e, 0x69, 0xdd, 0x21, 0x86, 0xd9, - 0xb4, 0x0d, 0xd3, 0x75, 0x29, 0x17, 0x26, 0x0c, 0x6a, 0x97, 0xb2, 0x50, 0x56, 0x4c, 0xc7, 0xa1, - 0x1c, 0x5a, 0x66, 0xf2, 0xa9, 0x38, 0xe6, 0x36, 0x81, 0x86, 0xf9, 0xac, 0x86, 0xa2, 0xbc, 0xec, - 0x52, 0xb7, 0x4a, 0x02, 0x08, 0x6b, 0x99, 0xed, 0x3d, 0xca, 0x98, 0x34, 0xaa, 0x39, 0x66, 0x5d, - 0x09, 0xf6, 0x13, 0xd2, 0xaa, 0x13, 0x57, 0x05, 0x8d, 0x4b, 0x2d, 0x52, 0x36, 0xab, 0x55, 0xba, - 0xe3, 0x06, 0x34, 0x97, 0xb3, 0xda, 0x07, 0x7f, 0x54, 0x50, 0x34, 0x4d, 0xcf, 0xdc, 0x0e, 0xf0, - 0x9e, 0xcf, 0x6c, 0x49, 0x5c, 0xcb, 0x76, 0xeb, 0xd1, 0xa8, 0x9c, 0xce, 0xb2, 0xe0, 0x8c, 0x65, - 0xc0, 0x6d, 0x3e, 0xa9, 0xcb, 0x38, 0x33, 0xf8, 0xe9, 0xd1, 0xb6, 0xe9, 0x51, 0x5a, 0x63, 0xf0, - 0x03, 0x6d, 0x2f, 0xf5, 0xe8, 0xbe, 0x5c, 0xdb, 0x71, 0x2d, 0x56, 0xde, 0xb6, 0xeb, 0x9e, 0xc9, - 0x29, 0x04, 0x44, 0x3f, 0x8d, 0x16, 0x3e, 0xf0, 0xc7, 0xe8, 0x23, 0xc6, 0x36, 0xfc, 0xfa, 0xf7, - 0xa1, 0xfa, 0xae, 0x5b, 0xa3, 0xeb, 0x8e, 0x53, 0x24, 0x1f, 0xed, 0x10, 0xc6, 0xf5, 0x9f, 0x6a, - 0x68, 0x31, 0xbb, 0x1d, 0x6b, 0x52, 0x97, 0x11, 0x5c, 0x43, 0x87, 0xbb, 0xfb, 0x62, 0xb3, 0xda, - 0xfc, 0xf0, 0xd2, 0xf8, 0xda, 0xf9, 0x7c, 0xc6, 0xc4, 0xc9, 0x83, 0xeb, 0xb0, 0xe7, 0xc2, 0x2b, - 0x5f, 0xfd, 0xfb, 0xe4, 0x81, 0xe2, 0x34, 0x8f, 0xf5, 0xca, 0xf4, 0x1b, 0x68, 0x3e, 0x15, 0x0f, - 0x80, 0xc6, 0xaf, 0xa3, 0x51, 0x39, 0x0e, 0x6d, 0x6b, 0x56, 0x9b, 0xd7, 0x96, 0x86, 0x8b, 0xaf, - 0x89, 0xe7, 0xbb, 0x96, 0xfe, 0x13, 0x0d, 0x9d, 0xca, 0xb0, 0x07, 0x32, 0x16, 0xc2, 0xdd, 0x64, - 0x84, 0xab, 0xc1, 0xb9, 0x4c, 0xc5, 0xb9, 0xe8, 0x97, 0x51, 0x4e, 0x40, 0xd9, 0x24, 0xfc, 0xb6, - 0xef, 0xee, 0xbe, 0x18, 0x54, 0x0a, 0x24, 0x28, 0x3a, 0x9e, 0x68, 0x08, 0xe8, 0x1f, 0xa2, 0xf1, - 0x50, 0x31, 0xc0, 0x5e, 0xca, 0x84, 0x1d, 0x6a, 0x0f, 0x70, 0xc3, 0x2e, 0x74, 0x0b, 0x90, 0xae, - 0x3b, 0x4e, 0x02, 0xd2, 0x0d, 0x84, 0x3a, 0x09, 0x0e, 0xba, 0x7b, 0x33, 0x2f, 0xb3, 0x61, 0xde, - 0xcf, 0x86, 0x79, 0x99, 0x43, 0x21, 0x1b, 0xe6, 0x1f, 0x9a, 0x75, 0x02, 0xb6, 0xc5, 0x90, 0xa5, - 0xfe, 0x47, 0x0d, 0x78, 0xc5, 0xbb, 0x49, 0xe3, 0x35, 0xfc, 0x92, 0xbc, 0xf0, 0x66, 0x04, 0xf9, - 0x90, 0x40, 0x7e, 0xa6, 0x27, 0x72, 0x09, 0x27, 0x02, 0xbd, 0x86, 0x4e, 0x04, 0xc8, 0x1f, 0xca, - 0x14, 0xf1, 0xff, 0x09, 0xd1, 0x97, 0x1a, 0x7a, 0x23, 0xa5, 0x23, 0x08, 0xd2, 0x87, 0x68, 0x22, - 0x9a, 0xa4, 0x20, 0x4e, 0xcb, 0x99, 0x71, 0x8a, 0xf8, 0x82, 0x48, 0x1d, 0x6a, 0x86, 0x0b, 0xf7, - 0x2f, 0x56, 0xc1, 0x0c, 0x8e, 0xf6, 0xd9, 0x12, 0xef, 0x45, 0x61, 0xf0, 0xff, 0x10, 0x26, 0x70, - 0xb2, 0x79, 0x46, 0x14, 0xb4, 0x7d, 0x88, 0x82, 0x3e, 0x83, 0x70, 0x30, 0xf5, 0x1e, 0x95, 0x4a, - 0x41, 0x96, 0x7c, 0x80, 0x0e, 0x47, 0x4a, 0x01, 0xc5, 0x15, 0x34, 0xfc, 0xa8, 0x54, 0x82, 0xae, - 0xe7, 0xb3, 0xf3, 0x46, 0xa9, 0x04, 0x1d, 0xfa, 0x26, 0xfa, 0x1d, 0xf4, 0x7a, 0xdb, 0x21, 0x63, - 0xeb, 0x96, 0xe5, 0x11, 0xd6, 0x1e, 0x4c, 0x4b, 0x68, 0xaa, 0x62, 0xf3, 0x2a, 0xb5, 0xdd, 0x72, - 0x3b, 0x48, 0x43, 0x22, 0x48, 0x13, 0x50, 0x7e, 0x1b, 0x62, 0x75, 0xab, 0x93, 0x61, 0xc2, 0x6e, - 0x00, 0xde, 0x14, 0x1a, 0x26, 0xbc, 0x21, 0xe0, 0x8d, 0x15, 0xfd, 0xbf, 0x7e, 0x49, 0x85, 0x57, - 0x85, 0xb3, 0xb1, 0xa2, 0xff, 0x57, 0xff, 0x4c, 0x43, 0xcb, 0xdd, 0x2e, 0x0a, 0xad, 0x0d, 0xdb, - 0x35, 0x1d, 0xfb, 0x53, 0x62, 0x6d, 0x11, 0xbb, 0xde, 0xe0, 0x01, 0xb4, 0x35, 0x74, 0xa4, 0x16, - 0xd4, 0x94, 0x7d, 0x96, 0xe5, 0x86, 0xa8, 0x87, 0x97, 0x78, 0xb8, 0x5d, 0xf9, 0x98, 0x70, 0x53, - 0x9a, 0xf6, 0x41, 0xe7, 0x03, 0x74, 0x4e, 0x09, 0x4b, 0x1f, 0xfc, 0xbe, 0x8f, 0x8e, 0x06, 0xcb, - 0xc1, 0x96, 0xcd, 0x38, 0xf5, 0x5a, 0xfb, 0x3d, 0x65, 0x7f, 0xab, 0xa1, 0x63, 0x5d, 0x5d, 0x00, - 0xc2, 0x75, 0x34, 0xea, 0xaf, 0x33, 0x8e, 0xcd, 0x38, 0x4c, 0x53, 0xd5, 0x51, 0xf2, 0x1a, 0x67, - 0xec, 0x3d, 0x9b, 0xf1, 0xfd, 0x9b, 0x96, 0x0d, 0x34, 0x23, 0x60, 0x6e, 0x99, 0xec, 0xdb, 0x94, - 0x13, 0x2b, 0x88, 0xc3, 0x39, 0x34, 0x2d, 0xc5, 0x65, 0xd9, 0xb6, 0x88, 0xcb, 0xed, 0x9a, 0x4d, - 0x3c, 0x88, 0xe9, 0x94, 0xac, 0xb8, 0xdb, 0x2e, 0xc7, 0x0b, 0xe8, 0xd0, 0x53, 0xca, 0x89, 0x57, - 0x36, 0xe5, 0xcb, 0x81, 0x50, 0x1f, 0x14, 0x85, 0xf0, 0xc2, 0xf4, 0x4b, 0xe8, 0x48, 0xac, 0x27, - 0x08, 0xc7, 0x71, 0x34, 0xd6, 0x30, 0x59, 0xd9, 0x6f, 0x2c, 0xa7, 0xfd, 0x68, 0x71, 0xb4, 0x01, - 0x8d, 0xf4, 0xf7, 0xd1, 0x9c, 0xb0, 0x2a, 0x88, 0x3e, 0x0b, 0xad, 0x4e, 0xaf, 0x83, 0x20, 0xd5, - 0x39, 0x1a, 0xf3, 0xfd, 0x7a, 0x22, 0x88, 0x5d, 0xb0, 0xb5, 0x6e, 0xd8, 0xb8, 0x80, 0xc6, 0xfc, - 0xe7, 0x32, 0x6f, 0x35, 0x89, 0xe0, 0x35, 0xb1, 0x76, 0x3a, 0xf3, 0x6d, 0xf9, 0xfe, 0x1f, 0xb5, - 0x9a, 0xa4, 0x38, 0xfa, 0x14, 0xfe, 0xe9, 0x7f, 0x18, 0x42, 0x27, 0x53, 0x59, 0x40, 0x14, 0xfa, - 0x0a, 0xf8, 0x3b, 0x68, 0x44, 0x80, 0xf4, 0x23, 0x3d, 0x2c, 0x46, 0x68, 0x2f, 0x44, 0x82, 0x71, - 0x11, 0xac, 0xf0, 0x87, 0x68, 0x4a, 0xd6, 0x8a, 0x41, 0x20, 0xb9, 0x0d, 0x0b, 0x6e, 0x2b, 0x99, - 0x9e, 0x1e, 0x74, 0x8c, 0x04, 0xc5, 0x49, 0x1a, 0x2d, 0xc0, 0xf7, 0xd1, 0x21, 0x60, 0xc1, 0xb8, - 0xc9, 0x77, 0xd8, 0xec, 0x2b, 0xc2, 0xeb, 0xd9, 0x4c, 0xaf, 0x32, 0x2a, 0x25, 0x61, 0x50, 0x3c, - 0x58, 0x09, 0x3d, 0xe9, 0x18, 0x4d, 0x89, 0xc0, 0x3d, 0x80, 0xb6, 0x25, 0xc2, 0xf5, 0x2b, 0x68, - 0x36, 0x5e, 0xd6, 0x8e, 0xe2, 0x09, 0x34, 0x16, 0xb8, 0x95, 0x4b, 0xe0, 0x58, 0xb1, 0x53, 0xa0, - 0x1f, 0x85, 0xc1, 0x5e, 0xda, 0x69, 0x36, 0xa9, 0xc7, 0x89, 0x25, 0x52, 0x0c, 0xd3, 0x2b, 0xb0, - 0x8e, 0xc7, 0xca, 0xdb, 0x5e, 0x0b, 0x68, 0x44, 0xea, 0x74, 0x98, 0xae, 0x8b, 0x49, 0x74, 0x9a, - 0x4f, 0xea, 0x79, 0x50, 0xf3, 0xc2, 0x1c, 0xa6, 0x2c, 0x58, 0xea, 0x37, 0x91, 0x1e, 0x51, 0x6f, - 0x0f, 0xc5, 0xee, 0x63, 0x83, 0x7a, 0xaa, 0x2b, 0xa0, 0x07, 0xd2, 0x3d, 0xcd, 0x01, 0x60, 0x7d, - 0x17, 0x1d, 0x94, 0x1e, 0xe4, 0xf6, 0x46, 0x5d, 0x07, 0x4a, 0x7f, 0xc5, 0xf1, 0x6a, 0xe7, 0x41, - 0x3f, 0x11, 0xd3, 0xaa, 0xd0, 0x06, 0xd6, 0x3f, 0x37, 0x26, 0x48, 0x83, 0x5a, 0x40, 0xf2, 0x20, - 0x11, 0xc9, 0x8a, 0x2a, 0x12, 0x31, 0x60, 0x23, 0x68, 0xd6, 0x3a, 0x68, 0xee, 0x53, 0x8b, 0xac, - 0xcb, 0x6d, 0x61, 0x10, 0xba, 0x19, 0xf4, 0xaa, 0xed, 0x5a, 0xe4, 0x13, 0x98, 0x34, 0xf2, 0x41, - 0xff, 0x41, 0x07, 0x63, 0xc4, 0xa6, 0x13, 0xad, 0xf0, 0x16, 0x53, 0x29, 0x5a, 0x61, 0x3f, 0xe3, - 0x6e, 0xe7, 0x21, 0xac, 0x97, 0x13, 0xf0, 0xed, 0xd7, 0xca, 0xf2, 0x79, 0x48, 0x2f, 0x27, 0x51, - 0xba, 0x87, 0xc6, 0x43, 0xc5, 0x4a, 0x7a, 0x39, 0xc2, 0x28, 0xf4, 0xb0, 0x7f, 0xcb, 0xcc, 0x3c, - 0xa4, 0x71, 0x7f, 0xa8, 0xb4, 0x0f, 0x0c, 0x36, 0x1c, 0xb3, 0xde, 0x1e, 0x4c, 0x3f, 0xd2, 0x20, - 0x47, 0x26, 0x35, 0x01, 0x6a, 0xdf, 0x45, 0x53, 0xf1, 0xe3, 0x06, 0xb5, 0x51, 0x15, 0xf5, 0x07, - 0x33, 0x73, 0xb2, 0x1a, 0x2d, 0xd6, 0x8f, 0xc1, 0x0a, 0xb5, 0x49, 0xf8, 0xbb, 0xe2, 0x84, 0x22, - 0xc0, 0xf6, 0x2d, 0x90, 0x0b, 0xa1, 0x0a, 0x40, 0x74, 0x1d, 0x8d, 0xc8, 0xc3, 0x0c, 0xc0, 0xb1, - 0x90, 0x89, 0x03, 0x8c, 0xc1, 0x44, 0x3f, 0x09, 0xaa, 0xbe, 0xd4, 0xa0, 0x1f, 0x07, 0xc9, 0xec, - 0x76, 0x68, 0xc8, 0xf8, 0x31, 0x99, 0x4b, 0x6b, 0x01, 0x00, 0xbe, 0x87, 0x0e, 0x3b, 0x26, 0xe3, - 0xe5, 0xa0, 0x8f, 0x72, 0x78, 0x1c, 0xe7, 0x33, 0xd1, 0xbc, 0x67, 0x32, 0x1e, 0x75, 0x3a, 0xed, - 0xc4, 0x8b, 0xf4, 0x7b, 0x80, 0xb1, 0xe0, 0x98, 0xdb, 0x24, 0x69, 0xf9, 0x3d, 0x8b, 0xa6, 0xc4, - 0xd9, 0x52, 0xf7, 0xb2, 0x35, 0x29, 0xca, 0x43, 0x8b, 0x6f, 0x35, 0x58, 0xcb, 0xbb, 0x7d, 0xb5, - 0x95, 0x11, 0x02, 0x67, 0x6e, 0x8d, 0x02, 0x09, 0x3d, 0x7b, 0xed, 0xf0, 0x9b, 0x17, 0xc7, 0x64, - 0x57, 0x6e, 0x8d, 0xea, 0xa4, 0x33, 0x3b, 0x64, 0x1d, 0xa9, 0x52, 0xcf, 0xda, 0xf7, 0x2d, 0xd9, - 0xef, 0xb5, 0xce, 0xde, 0x2f, 0xda, 0x0f, 0x50, 0xd9, 0x8c, 0x51, 0x19, 0x56, 0xa3, 0x02, 0x63, - 0xb3, 0x43, 0x68, 0xff, 0xe6, 0x60, 0x09, 0x76, 0x60, 0x10, 0x7e, 0x91, 0x6a, 0xd7, 0x5d, 0x4b, - 0x6c, 0x71, 0x7a, 0xaf, 0x3f, 0x7e, 0x7e, 0x15, 0x9b, 0x2a, 0x50, 0xe9, 0xf2, 0x41, 0xaf, 0xc1, - 0xbe, 0x2c, 0xd9, 0x69, 0xca, 0x6b, 0x1d, 0xee, 0xfb, 0xb5, 0xae, 0xfd, 0x66, 0x11, 0xbd, 0x2a, - 0x3a, 0xc2, 0x7f, 0xd6, 0xd0, 0x68, 0xa0, 0x21, 0xf1, 0x85, 0x4c, 0x2f, 0x49, 0xca, 0x36, 0xb7, - 0xd6, 0x8f, 0x89, 0x24, 0xa0, 0xdf, 0xfb, 0xf1, 0xdf, 0xff, 0xfb, 0xf3, 0xa1, 0x6f, 0xe2, 0x82, - 0x38, 0x6b, 0x5b, 0x95, 0xc7, 0x6e, 0xed, 0xd3, 0xb6, 0xb6, 0x7a, 0x35, 0x76, 0xbb, 0x24, 0xdc, - 0x9e, 0xb1, 0x1b, 0xd1, 0x98, 0x7b, 0xf8, 0x9f, 0x1a, 0xc2, 0xdd, 0x3a, 0x10, 0x5f, 0xef, 0x0d, - 0x2b, 0x55, 0x03, 0xe7, 0xde, 0x1e, 0xcc, 0x18, 0xd8, 0xdd, 0x11, 0xec, 0x6e, 0xe2, 0x1b, 0x89, - 0xec, 0x80, 0x52, 0xa5, 0x15, 0x62, 0x95, 0x44, 0x14, 0xff, 0x4a, 0x43, 0xe3, 0x21, 0x4d, 0x86, - 0x57, 0x7b, 0x83, 0x0a, 0x35, 0xcf, 0xbd, 0xd5, 0x57, 0xf3, 0x36, 0xf8, 0xb3, 0x02, 0xfc, 0x02, - 0x3e, 0x95, 0x08, 0xbe, 0x9d, 0x16, 0x19, 0xe1, 0xf8, 0x77, 0x1a, 0x9a, 0x8c, 0x49, 0x3c, 0x95, - 0x01, 0x14, 0x33, 0xc9, 0x5d, 0xed, 0xdb, 0xa4, 0x0d, 0x76, 0x45, 0x80, 0x7d, 0x13, 0x2f, 0x26, - 0x82, 0x65, 0x31, 0x6c, 0xff, 0xd1, 0xd0, 0xd1, 0x64, 0xb5, 0x87, 0x6f, 0xf6, 0xc6, 0x90, 0x29, - 0x34, 0x73, 0xb7, 0x06, 0x77, 0x00, 0x5c, 0x0a, 0x82, 0xcb, 0xdb, 0xf8, 0x5a, 0x22, 0x97, 0x3a, - 0xe1, 0xe5, 0xb0, 0xfa, 0x2b, 0xd7, 0xa8, 0x27, 0x0b, 0x8c, 0xdd, 0x20, 0xc3, 0xec, 0xe1, 0xcf, - 0x35, 0x34, 0x11, 0xed, 0x06, 0x5f, 0xee, 0x17, 0x58, 0xc0, 0xe8, 0x4a, 0xff, 0x86, 0xc0, 0x64, - 0x55, 0x30, 0x39, 0x83, 0x4f, 0x2b, 0x31, 0xf1, 0x41, 0x47, 0x44, 0x92, 0x1a, 0xe2, 0x6e, 0x45, - 0xa8, 0x88, 0x38, 0x41, 0xe3, 0xe9, 0xe7, 0x05, 0xe2, 0x65, 0xbc, 0x94, 0x88, 0x38, 0xa4, 0x49, - 0x8d, 0x5d, 0x21, 0x83, 0xf7, 0xfc, 0xb1, 0x3f, 0x11, 0xf2, 0xb4, 0xee, 0x38, 0x2a, 0xb8, 0x13, - 0x95, 0xac, 0x0a, 0xee, 0x64, 0x6d, 0xaa, 0x2f, 0x09, 0xdc, 0x3a, 0x9e, 0xef, 0x85, 0x1b, 0xff, - 0x49, 0x43, 0x93, 0x31, 0xd9, 0xa6, 0x92, 0x22, 0x53, 0xf5, 0xa5, 0x4a, 0x8a, 0x4c, 0x57, 0x9e, - 0x3d, 0x86, 0x48, 0x5c, 0x94, 0xe2, 0x5f, 0x68, 0x68, 0x44, 0x8a, 0x3d, 0xbc, 0xa6, 0xd4, 0x6f, - 0x44, 0x6f, 0xe6, 0x2e, 0xf6, 0x65, 0x03, 0x10, 0x17, 0x04, 0xc4, 0x37, 0xf0, 0xf1, 0x44, 0x88, - 0x52, 0x72, 0xe2, 0xbf, 0x68, 0x68, 0xba, 0x4b, 0x4c, 0xe2, 0x6b, 0x0a, 0x19, 0x2d, 0x45, 0xa3, - 0xe6, 0xae, 0x0f, 0x64, 0x0b, 0x98, 0xaf, 0x0a, 0xcc, 0x17, 0xf1, 0x85, 0x30, 0xe6, 0xee, 0xeb, - 0x2c, 0xd6, 0xa0, 0x1f, 0xc7, 0x14, 0x2e, 0xfe, 0x9b, 0x86, 0xa6, 0xbb, 0x84, 0xa4, 0x0a, 0x93, - 0x34, 0x25, 0xab, 0xc2, 0x24, 0x55, 0xb9, 0xea, 0xb7, 0x05, 0x93, 0x1b, 0xf8, 0x7a, 0xf2, 0x1a, - 0x2a, 0xd4, 0x4f, 0x7c, 0x09, 0x8d, 0xc9, 0xe6, 0x3d, 0x5f, 0xda, 0xe0, 0x4d, 0xc2, 0x63, 0x92, - 0x12, 0xab, 0xcd, 0xb7, 0x04, 0xb5, 0xab, 0xb2, 0x54, 0xa5, 0xe8, 0x57, 0x7d, 0x4d, 0x10, 0x5a, - 0xc1, 0xcb, 0xa9, 0x49, 0xd1, 0x74, 0x9c, 0xb2, 0xe4, 0xe0, 0x01, 0xd0, 0x67, 0x1a, 0x3a, 0x22, - 0x9c, 0xb1, 0x98, 0x12, 0xc4, 0x37, 0x94, 0x63, 0x9b, 0x24, 0x4b, 0x73, 0xef, 0x0c, 0x6a, 0x0e, - 0x64, 0xb6, 0x04, 0x99, 0x02, 0xbe, 0x95, 0xfd, 0x76, 0xe4, 0x14, 0x36, 0x5d, 0x4b, 0x5e, 0x1f, - 0x84, 0x56, 0x2a, 0x63, 0x57, 0x94, 0xec, 0xe1, 0x2f, 0x35, 0x74, 0x28, 0x72, 0x10, 0x8d, 0xbf, - 0xa1, 0x34, 0x59, 0xbb, 0xce, 0xf3, 0x73, 0x97, 0xfb, 0xb6, 0x03, 0x32, 0x37, 0x05, 0x99, 0xab, - 0xf8, 0x72, 0xea, 0x9b, 0xe1, 0x8c, 0x05, 0x7a, 0xd3, 0xd8, 0x8d, 0x9f, 0xb2, 0xef, 0xe1, 0x5f, - 0x0e, 0xa1, 0xb9, 0xec, 0xc3, 0x74, 0xbc, 0xd9, 0x27, 0xb8, 0xb4, 0xab, 0x81, 0xdc, 0xd6, 0xcb, - 0x3b, 0x02, 0xda, 0x15, 0x41, 0xfb, 0x3b, 0xf8, 0xb1, 0x0a, 0xed, 0x72, 0x43, 0x9c, 0xb9, 0xdb, - 0x55, 0xd3, 0x31, 0x76, 0x13, 0xef, 0x26, 0xf6, 0x92, 0x22, 0xf3, 0x99, 0x26, 0xee, 0x6e, 0xb0, - 0xa1, 0x86, 0xba, 0x7d, 0x15, 0x94, 0x3b, 0xaf, 0x6e, 0x00, 0x74, 0xe6, 0x05, 0x9d, 0x1c, 0x9e, - 0x4d, 0xa4, 0xe3, 0x83, 0xf8, 0xb5, 0x86, 0x50, 0xe7, 0xf6, 0x00, 0x2b, 0x2c, 0x0a, 0x5d, 0xd7, - 0x19, 0xb9, 0x4b, 0xfd, 0x19, 0x01, 0xb6, 0x33, 0x02, 0xdb, 0x29, 0x7c, 0x32, 0x11, 0x1b, 0xef, - 0x60, 0xfa, 0x42, 0x43, 0x53, 0x91, 0xeb, 0x33, 0x5f, 0x57, 0xa8, 0x25, 0x9d, 0xa4, 0x0b, 0xd3, - 0xdc, 0xb5, 0x41, 0x4c, 0x01, 0xf4, 0xb2, 0x00, 0xbd, 0x88, 0xf5, 0x44, 0xd0, 0xd1, 0x5b, 0xcd, - 0xbf, 0x6a, 0x68, 0x26, 0xe9, 0x26, 0x51, 0x25, 0x4f, 0x65, 0x5c, 0x60, 0xaa, 0xe4, 0xa9, 0xac, - 0x0b, 0x4c, 0xfd, 0x2d, 0xc1, 0xc1, 0xc0, 0xab, 0xbd, 0x39, 0x84, 0x65, 0xf4, 0x17, 0x5a, 0xe4, - 0x8e, 0xbc, 0x1f, 0x0d, 0x1d, 0x8d, 0xff, 0x95, 0xfe, 0x0d, 0x01, 0xf9, 0x45, 0x81, 0x7c, 0x15, - 0x9f, 0x4b, 0x16, 0x48, 0x1d, 0x8b, 0x30, 0x6e, 0x5f, 0x94, 0x86, 0x9c, 0xa9, 0x8b, 0xd2, 0xc1, - 0xa0, 0x27, 0x7f, 0x60, 0xd0, 0x43, 0x94, 0x86, 0xa0, 0xfb, 0xea, 0x69, 0x26, 0xe9, 0x0b, 0x12, - 0x95, 0x61, 0x93, 0xf1, 0xe5, 0x8a, 0xca, 0xb0, 0xc9, 0xfa, 0x70, 0xa5, 0xc7, 0x76, 0xa0, 0x2e, - 0xf2, 0x6b, 0xc4, 0x1a, 0xff, 0x43, 0x43, 0xc7, 0x52, 0xbe, 0xed, 0xc1, 0xb7, 0x06, 0x43, 0xd3, - 0xf9, 0x7c, 0x28, 0xb7, 0xfe, 0x12, 0x1e, 0x80, 0xd2, 0x25, 0x41, 0x29, 0x8f, 0x57, 0xd2, 0x28, - 0xad, 0x3b, 0x4e, 0xdc, 0x07, 0x2b, 0xdc, 0xf9, 0xea, 0xf9, 0x9c, 0xf6, 0xf5, 0xf3, 0x39, 0xed, - 0xd9, 0xf3, 0x39, 0xed, 0x67, 0x2f, 0xe6, 0x0e, 0x7c, 0xfd, 0x62, 0xee, 0xc0, 0xbf, 0x5e, 0xcc, - 0x1d, 0x78, 0x7c, 0xae, 0x6e, 0xf3, 0xc6, 0x4e, 0x25, 0x5f, 0xa5, 0xdb, 0x61, 0x8f, 0xfe, 0x96, - 0xc3, 0xf8, 0x24, 0x94, 0xdb, 0x5a, 0x4d, 0xc2, 0x2a, 0x23, 0xe2, 0x63, 0xa9, 0x8b, 0xff, 0x0b, - 0x00, 0x00, 0xff, 0xff, 0x77, 0x67, 0x2d, 0x08, 0x22, 0x28, 0x00, 0x00, + 0xf5, 0xf7, 0x5a, 0x89, 0x22, 0x8d, 0x6c, 0x89, 0x1a, 0xcb, 0x3f, 0x42, 0x3b, 0xb4, 0xbc, 0xb2, + 0x62, 0x59, 0x96, 0xb8, 0x36, 0xed, 0x7c, 0xfd, 0x2b, 0x8e, 0x4d, 0xfa, 0x6b, 0x49, 0x76, 0x12, + 0xdb, 0x21, 0xdd, 0x06, 0x30, 0xda, 0x32, 0x4b, 0x72, 0x48, 0x6e, 0xbd, 0xda, 0x61, 0x76, 0x46, + 0x4e, 0x18, 0x55, 0x40, 0xdb, 0x5b, 0x73, 0x28, 0x0a, 0x14, 0x68, 0x6f, 0x45, 0x2f, 0x3d, 0x16, + 0x28, 0x02, 0x04, 0x0d, 0x50, 0xf4, 0x90, 0x53, 0x73, 0xe8, 0x21, 0x45, 0x8b, 0xa2, 0xa7, 0x34, + 0xb0, 0xfb, 0x87, 0x14, 0x3b, 0xf3, 0x96, 0xdc, 0x5d, 0xee, 0x2e, 0x87, 0xb2, 0x7a, 0x22, 0x77, + 0x76, 0xde, 0x9b, 0xcf, 0xe7, 0xcd, 0xcc, 0x9b, 0xcf, 0xcc, 0x2c, 0x3a, 0xf3, 0x09, 0xe1, 0x66, + 0xbd, 0x6d, 0x5a, 0x8e, 0x21, 0xfe, 0x51, 0x97, 0x18, 0xb4, 0xc6, 0x88, 0xfb, 0x94, 0xb8, 0xc6, + 0x87, 0x5b, 0xc4, 0xed, 0xe6, 0x3b, 0x2e, 0xe5, 0x14, 0x1f, 0xef, 0x55, 0xcc, 0xfb, 0x15, 0xf3, + 0x7e, 0xc5, 0xec, 0x72, 0x9d, 0xb2, 0x4d, 0xca, 0x8c, 0x9a, 0xc9, 0x88, 0xb4, 0x32, 0x9e, 0x5e, + 0xa8, 0x11, 0x6e, 0x5e, 0x30, 0x3a, 0x66, 0xcb, 0x72, 0x4c, 0x6e, 0x51, 0x47, 0x3a, 0xca, 0xce, + 0xb5, 0x68, 0x8b, 0x8a, 0xbf, 0x86, 0xf7, 0x0f, 0x4a, 0x4f, 0xb4, 0x28, 0x6d, 0xd9, 0xc4, 0x30, + 0x3b, 0x96, 0x61, 0x3a, 0x0e, 0xe5, 0xc2, 0x84, 0xc1, 0xdb, 0xa5, 0x34, 0x94, 0x35, 0xd3, 0xb6, + 0x29, 0x87, 0x9a, 0xa9, 0x7c, 0x6a, 0xb6, 0xb9, 0x49, 0xa0, 0x62, 0x3e, 0xad, 0xa2, 0x28, 0xaf, + 0x3a, 0xd4, 0xa9, 0x13, 0x1f, 0x42, 0x21, 0xb5, 0xbe, 0x4b, 0x19, 0x93, 0x46, 0x4d, 0xdb, 0x6c, + 0x29, 0xc1, 0x7e, 0x42, 0xba, 0x2d, 0xe2, 0xa8, 0xa0, 0x71, 0x68, 0x83, 0x54, 0xcd, 0x7a, 0x9d, + 0x6e, 0x39, 0x3e, 0xcd, 0xe5, 0xb4, 0xfa, 0xfe, 0x1f, 0x15, 0x14, 0x1d, 0xd3, 0x35, 0x37, 0x7d, + 0xbc, 0xe7, 0x53, 0x6b, 0x12, 0xa7, 0x61, 0x39, 0xad, 0x70, 0x54, 0x16, 0xd3, 0x2c, 0x38, 0xf3, + 0xab, 0xad, 0xa6, 0xc2, 0xed, 0x10, 0x57, 0xf4, 0xb6, 0x69, 0xa7, 0xb0, 0xeb, 0x3c, 0x69, 0xc9, + 0x6e, 0x61, 0xf0, 0x33, 0xa4, 0x6e, 0xc7, 0xa5, 0xb4, 0xc9, 0xe0, 0x07, 0xea, 0x5e, 0x1a, 0x82, + 0xb6, 0xda, 0xdc, 0x72, 0x1a, 0xac, 0xba, 0x69, 0xb5, 0x5c, 0x93, 0x53, 0x88, 0x9f, 0x9e, 0x43, + 0x27, 0xde, 0xf3, 0x86, 0xf4, 0x83, 0x3e, 0xce, 0x35, 0xaf, 0x93, 0xcb, 0xe4, 0xc3, 0x2d, 0xc2, + 0xb8, 0xfe, 0x13, 0x0d, 0xbd, 0x96, 0x50, 0x81, 0x75, 0xa8, 0xc3, 0x08, 0xfe, 0x00, 0xcd, 0x06, + 0x48, 0xca, 0x21, 0x72, 0x4c, 0x9b, 0xd7, 0x96, 0xa6, 0x0a, 0xab, 0xf9, 0x94, 0x79, 0x95, 0x8f, + 0x7a, 0x2c, 0xbd, 0xf4, 0xd5, 0x37, 0x27, 0xf7, 0x95, 0x33, 0x34, 0x52, 0xae, 0x2f, 0xa2, 0x05, + 0x01, 0xe1, 0x11, 0x63, 0x6b, 0x1e, 0x87, 0x77, 0x81, 0xc2, 0x5d, 0xa7, 0x49, 0x8b, 0xb6, 0xed, + 0x43, 0xfd, 0xb9, 0x86, 0x4e, 0xa7, 0xd7, 0x03, 0xc4, 0x4d, 0x74, 0x68, 0x30, 0x1e, 0x1e, 0xe6, + 0xb1, 0xa5, 0xa9, 0xc2, 0xf9, 0x54, 0xcc, 0xe0, 0x3a, 0xe8, 0x19, 0x60, 0xcf, 0xf2, 0x48, 0xab, + 0x4c, 0xbf, 0x81, 0xe6, 0x13, 0xf1, 0x00, 0x68, 0xfc, 0x2a, 0x9a, 0x90, 0x53, 0xcb, 0x6a, 0x88, + 0xa0, 0x8d, 0x95, 0x5f, 0x11, 0xcf, 0x77, 0x1b, 0xfa, 0xcf, 0x34, 0x74, 0x2a, 0xc5, 0x1e, 0xc8, + 0x34, 0x10, 0x1e, 0x24, 0x03, 0xf1, 0xdf, 0x2d, 0x97, 0x4c, 0x94, 0x8b, 0x7e, 0x19, 0x65, 0x05, + 0x94, 0x75, 0xc2, 0x6f, 0x7b, 0xee, 0xee, 0x8b, 0x79, 0xa2, 0x40, 0x82, 0xa2, 0xe3, 0xb1, 0x86, + 0x80, 0xfe, 0x21, 0x9a, 0x0a, 0x14, 0x03, 0xec, 0xa5, 0x54, 0xd8, 0x81, 0xfa, 0x00, 0x37, 0xe8, + 0x42, 0x6f, 0x00, 0xd2, 0xa2, 0x6d, 0xc7, 0x20, 0x5d, 0x43, 0xa8, 0x9f, 0xb3, 0xa1, 0xb9, 0xd7, + 0xf3, 0x32, 0xc1, 0xe7, 0xbd, 0x04, 0x9f, 0x97, 0xcb, 0x02, 0x24, 0xf8, 0xfc, 0x43, 0xb3, 0x45, + 0xc0, 0xb6, 0x1c, 0xb0, 0xd4, 0xbf, 0xd0, 0x80, 0x57, 0xb4, 0x99, 0x24, 0x5e, 0x63, 0x2f, 0xc8, + 0x0b, 0xaf, 0x87, 0x90, 0xef, 0x17, 0xc8, 0xcf, 0x0c, 0x45, 0x2e, 0xe1, 0x84, 0xa0, 0x37, 0x61, + 0xc6, 0x17, 0x6d, 0xfb, 0xa1, 0xcc, 0x7a, 0xff, 0x9b, 0x10, 0x7d, 0xe9, 0x67, 0x8e, 0xc1, 0x86, + 0x20, 0x48, 0xef, 0xa3, 0xe9, 0x70, 0xde, 0x85, 0x38, 0x2d, 0xa7, 0xc6, 0x29, 0xe4, 0x0b, 0x22, + 0x75, 0xb0, 0x13, 0x2c, 0xdc, 0xbb, 0x58, 0xf9, 0x33, 0x38, 0xdc, 0x66, 0x57, 0xf4, 0x8b, 0xc2, + 0xe0, 0xff, 0x11, 0x4c, 0xe0, 0x78, 0xf3, 0x94, 0x28, 0x68, 0x7b, 0x10, 0x05, 0x7d, 0x0e, 0x61, + 0x7f, 0xea, 0x3d, 0xaa, 0x54, 0xfc, 0x2c, 0xf9, 0x00, 0x1d, 0x0a, 0x95, 0x02, 0x8a, 0x2b, 0x68, + 0xec, 0x51, 0xa5, 0x02, 0x4d, 0xcf, 0xa7, 0xe7, 0x8d, 0x4a, 0x05, 0x1a, 0xf4, 0x4c, 0xf4, 0x3b, + 0xe8, 0xd5, 0x9e, 0x43, 0xc6, 0x8a, 0x8d, 0x86, 0x4b, 0x58, 0x6f, 0x30, 0x2d, 0xa1, 0x4c, 0xcd, + 0xe2, 0x75, 0x6a, 0x39, 0xd5, 0x5e, 0x90, 0xf6, 0x8b, 0x20, 0x4d, 0x43, 0xf9, 0x6d, 0x88, 0xd5, + 0xad, 0x7e, 0x86, 0x09, 0xba, 0x01, 0x78, 0x19, 0x34, 0x46, 0x78, 0x5b, 0xc0, 0x9b, 0x2c, 0x7b, + 0x7f, 0xbd, 0x92, 0x1a, 0xaf, 0x0b, 0x67, 0x93, 0x65, 0xef, 0xaf, 0xfe, 0xa9, 0x86, 0x96, 0x07, + 0x5d, 0x94, 0xba, 0x6b, 0x96, 0x63, 0xda, 0xd6, 0x27, 0xa4, 0xb1, 0x41, 0xac, 0x56, 0x9b, 0xfb, + 0xd0, 0x0a, 0xe8, 0x70, 0xd3, 0x7f, 0x53, 0xf5, 0x58, 0x56, 0xdb, 0xe2, 0x3d, 0x74, 0xe2, 0xa1, + 0xde, 0xcb, 0xc7, 0x84, 0x9b, 0xd2, 0x74, 0x04, 0x3a, 0xef, 0xa1, 0x73, 0x4a, 0x58, 0x46, 0xe0, + 0xf7, 0x01, 0x3a, 0xe2, 0x2f, 0x07, 0x1b, 0x16, 0xe3, 0xd4, 0xed, 0xee, 0xf5, 0x94, 0xfd, 0x9d, + 0x86, 0x8e, 0x0e, 0x34, 0x01, 0x08, 0x8b, 0x68, 0xc2, 0x5b, 0x67, 0x6c, 0x8b, 0x71, 0x98, 0xa6, + 0xaa, 0xa3, 0xe4, 0x15, 0xce, 0xd8, 0x3b, 0x16, 0xe3, 0x7b, 0x37, 0x2d, 0xdb, 0x68, 0x4e, 0xc0, + 0xdc, 0x30, 0xd9, 0x77, 0x29, 0x27, 0x0d, 0x3f, 0x0e, 0xe7, 0xd0, 0xac, 0xd4, 0xcb, 0x55, 0xab, + 0x41, 0x1c, 0x6e, 0x35, 0x2d, 0xe2, 0x42, 0x4c, 0x33, 0xf2, 0xc5, 0xdd, 0x5e, 0x39, 0x5e, 0x40, + 0x07, 0x9f, 0x52, 0x4e, 0xdc, 0xaa, 0x29, 0x3b, 0x07, 0x42, 0x7d, 0x40, 0x14, 0x42, 0x87, 0xe9, + 0x97, 0xd0, 0xe1, 0x48, 0x4b, 0x10, 0x8e, 0xe3, 0x68, 0xb2, 0x6d, 0xb2, 0xaa, 0x57, 0x59, 0x4e, + 0xfb, 0x89, 0xf2, 0x44, 0x1b, 0x2a, 0xe9, 0xef, 0xa2, 0x9c, 0xb0, 0x2a, 0x89, 0x36, 0x4b, 0xdd, + 0x7e, 0xab, 0xbb, 0x41, 0xaa, 0x73, 0x34, 0xe9, 0xf9, 0x75, 0x45, 0x10, 0x07, 0x60, 0x6b, 0x83, + 0xb0, 0x71, 0x09, 0x4d, 0x7a, 0xcf, 0x55, 0xde, 0xed, 0x10, 0xc1, 0x6b, 0xba, 0xb0, 0x98, 0xda, + 0x5b, 0x9e, 0xff, 0x47, 0xdd, 0x0e, 0x29, 0x4f, 0x3c, 0x85, 0x7f, 0xfa, 0x1f, 0xf7, 0xa3, 0x93, + 0x89, 0x2c, 0x20, 0x0a, 0x23, 0x05, 0xfc, 0x2d, 0x34, 0x2e, 0x40, 0x7a, 0x91, 0x1e, 0x13, 0x23, + 0x74, 0x18, 0x22, 0xc1, 0xb8, 0x0c, 0x56, 0xf8, 0x7d, 0x94, 0x91, 0x6f, 0xc5, 0x20, 0x90, 0xdc, + 0xc6, 0x04, 0xb7, 0x95, 0x74, 0x9d, 0xd9, 0x37, 0x12, 0x14, 0x67, 0x68, 0xb8, 0x00, 0xdf, 0x47, + 0x07, 0x81, 0x05, 0xe3, 0x26, 0xdf, 0x62, 0xc7, 0x5e, 0x12, 0x5e, 0xcf, 0xa6, 0x7a, 0x95, 0x51, + 0xa9, 0x08, 0x83, 0xf2, 0x81, 0x5a, 0xe0, 0x49, 0xc7, 0x28, 0x23, 0x25, 0x33, 0xd4, 0xad, 0x10, + 0xae, 0x5f, 0x41, 0xc7, 0xa2, 0x65, 0xbd, 0x28, 0x9e, 0x40, 0x93, 0xbe, 0x5b, 0xb9, 0x04, 0x4e, + 0x96, 0xfb, 0x05, 0xfa, 0x11, 0x18, 0xec, 0x95, 0xad, 0x4e, 0x87, 0xba, 0x9c, 0x34, 0x44, 0x8a, + 0x61, 0x7a, 0x0d, 0xd6, 0xf1, 0x48, 0x79, 0xcf, 0x6b, 0x09, 0x8d, 0xcb, 0xbd, 0x04, 0x4c, 0xd7, + 0xd3, 0x71, 0x74, 0x3a, 0x4f, 0x5a, 0x79, 0xd8, 0x71, 0x08, 0x73, 0x98, 0xb2, 0x60, 0xa9, 0xdf, + 0x44, 0x7a, 0x48, 0xbd, 0x3d, 0x14, 0x1b, 0xaa, 0x35, 0xea, 0xaa, 0xae, 0x80, 0x2e, 0x48, 0xf7, + 0x24, 0x07, 0x80, 0xf5, 0x6d, 0x74, 0x40, 0x7a, 0x90, 0x3b, 0x36, 0x75, 0x1d, 0x28, 0xfd, 0x95, + 0xa7, 0xea, 0xfd, 0x07, 0xfd, 0x44, 0x44, 0xab, 0x42, 0x1d, 0x58, 0xff, 0x9c, 0x88, 0x20, 0xf5, + 0xdf, 0x02, 0x92, 0x07, 0xb1, 0x48, 0x56, 0x54, 0x91, 0x88, 0x01, 0x1b, 0x42, 0x53, 0xe8, 0xa3, + 0xb9, 0x4f, 0x1b, 0xa4, 0x28, 0x77, 0xba, 0x7e, 0xe8, 0xe6, 0xd0, 0xcb, 0x96, 0xd3, 0x20, 0x1f, + 0xc3, 0xa4, 0x91, 0x0f, 0xfa, 0x0f, 0xfb, 0x18, 0x43, 0x36, 0xfd, 0x68, 0x05, 0x77, 0xcd, 0x4a, + 0xd1, 0x0a, 0xfa, 0x99, 0x72, 0xfa, 0x0f, 0x41, 0xbd, 0x1c, 0x83, 0x6f, 0xaf, 0x56, 0x96, 0xcf, + 0x02, 0x7a, 0x39, 0x8e, 0xd2, 0x3d, 0x34, 0x15, 0x28, 0x56, 0xd2, 0xcb, 0x21, 0x46, 0x81, 0x87, + 0xbd, 0x5b, 0x66, 0xe6, 0x21, 0x8d, 0x7b, 0x43, 0xa5, 0x77, 0x06, 0x12, 0xda, 0x1d, 0xff, 0x58, + 0x83, 0x1c, 0x19, 0x57, 0x05, 0xa8, 0x7d, 0x1f, 0x65, 0xa2, 0x27, 0x28, 0x6a, 0xa3, 0x2a, 0xec, + 0x0f, 0x66, 0xe6, 0x4c, 0x3d, 0x5c, 0xac, 0x1f, 0x85, 0x15, 0x6a, 0x9d, 0xf0, 0xb7, 0xc5, 0xa1, + 0x8b, 0x8f, 0xed, 0x3b, 0x20, 0x17, 0x02, 0x2f, 0x00, 0xd1, 0x75, 0x34, 0x2e, 0xcf, 0x67, 0x00, + 0xc7, 0x42, 0x2a, 0x0e, 0x30, 0x06, 0x13, 0xfd, 0x24, 0xa8, 0xfa, 0x4a, 0x9b, 0x7e, 0xe4, 0x27, + 0xb3, 0xdb, 0x81, 0x21, 0xe3, 0xc5, 0x24, 0x97, 0x54, 0x03, 0x00, 0xfc, 0x00, 0x1d, 0xb2, 0x4d, + 0xc6, 0xab, 0x7e, 0x1b, 0xd5, 0xe0, 0x38, 0xce, 0xa7, 0xa2, 0x79, 0xc7, 0x64, 0x3c, 0xec, 0x74, + 0xd6, 0x8e, 0x16, 0xe9, 0xf7, 0x00, 0x63, 0xc9, 0x36, 0x37, 0x49, 0xdc, 0xf2, 0x7b, 0x16, 0x65, + 0xc4, 0x71, 0xd9, 0xe0, 0xb2, 0x35, 0x23, 0xca, 0x03, 0x8b, 0x6f, 0xdd, 0x5f, 0xcb, 0x07, 0x7d, + 0xf5, 0x94, 0x11, 0x02, 0x67, 0x4e, 0x93, 0x02, 0x09, 0x3d, 0x7d, 0xed, 0xf0, 0xaa, 0x97, 0x27, + 0x65, 0x53, 0x4e, 0x93, 0xea, 0xa4, 0x3f, 0x3b, 0xe4, 0x3b, 0x52, 0xa7, 0x6e, 0x63, 0xcf, 0xb7, + 0x64, 0x7f, 0xd0, 0xfa, 0x7b, 0xbf, 0x70, 0x3b, 0x40, 0x65, 0x3d, 0x42, 0x65, 0x4c, 0x8d, 0x0a, + 0x8c, 0xcd, 0x3e, 0xa1, 0xbd, 0x9b, 0x83, 0x15, 0xd8, 0x81, 0x41, 0xf8, 0x45, 0xaa, 0x2d, 0x3a, + 0x0d, 0xb1, 0xc5, 0x19, 0xbe, 0xfe, 0x78, 0xf9, 0x55, 0x6c, 0xaa, 0x40, 0xa5, 0xcb, 0x07, 0xbd, + 0x09, 0xfb, 0xb2, 0x78, 0xa7, 0x09, 0xdd, 0x3a, 0x36, 0x72, 0xb7, 0x16, 0xbe, 0x59, 0x44, 0x2f, + 0x8b, 0x86, 0xf0, 0x9f, 0x35, 0x34, 0xe1, 0x6b, 0x48, 0x7c, 0x21, 0xd5, 0x4b, 0x9c, 0xb2, 0xcd, + 0x16, 0x46, 0x31, 0x91, 0x04, 0xf4, 0x7b, 0x3f, 0xfd, 0xfb, 0x7f, 0x7e, 0xb9, 0xff, 0xff, 0x71, + 0x49, 0x9c, 0x07, 0xae, 0xca, 0xa3, 0xc1, 0xde, 0x89, 0x60, 0x4f, 0xbd, 0x1a, 0xdb, 0x03, 0x12, + 0x6e, 0xc7, 0xd8, 0x0e, 0x69, 0xcc, 0x1d, 0xfc, 0x4f, 0x0d, 0xe1, 0x41, 0x1d, 0x88, 0xaf, 0x0f, + 0x87, 0x95, 0xa8, 0x81, 0xb3, 0x6f, 0xee, 0xce, 0x18, 0xd8, 0xdd, 0x11, 0xec, 0x6e, 0xe2, 0x1b, + 0xb1, 0xec, 0x80, 0x52, 0xad, 0x1b, 0x60, 0x15, 0x47, 0x14, 0xff, 0x46, 0x43, 0x53, 0x01, 0x4d, + 0x86, 0x57, 0x87, 0x83, 0x0a, 0x54, 0xcf, 0xbe, 0x31, 0x52, 0xf5, 0x1e, 0xf8, 0xb3, 0x02, 0xfc, + 0x02, 0x3e, 0x15, 0x0b, 0xbe, 0x97, 0x16, 0x19, 0xe1, 0xf8, 0xf7, 0x1a, 0x9a, 0x89, 0x48, 0x3c, + 0x95, 0x01, 0x14, 0x31, 0xc9, 0x5e, 0x1d, 0xd9, 0xa4, 0x07, 0x76, 0x45, 0x80, 0x7d, 0x1d, 0x9f, + 0x8e, 0x05, 0xcb, 0x22, 0xd8, 0xfe, 0xad, 0xa1, 0x23, 0xf1, 0x6a, 0x0f, 0xdf, 0x1c, 0x8e, 0x21, + 0x55, 0x68, 0x66, 0x6f, 0xed, 0xde, 0x01, 0x70, 0x29, 0x09, 0x2e, 0x6f, 0xe2, 0x6b, 0xb1, 0x5c, + 0x5a, 0x84, 0x57, 0x83, 0xea, 0xaf, 0xda, 0xa4, 0xae, 0x2c, 0x30, 0xb6, 0xfd, 0x0c, 0xb3, 0x83, + 0x3f, 0xd3, 0xd0, 0x74, 0xb8, 0x19, 0x7c, 0x79, 0x54, 0x60, 0x3e, 0xa3, 0x2b, 0xa3, 0x1b, 0x02, + 0x93, 0x55, 0xc1, 0xe4, 0x0c, 0x5e, 0x54, 0x62, 0xe2, 0x81, 0x0e, 0x89, 0x24, 0x35, 0xc4, 0x83, + 0x8a, 0x50, 0x11, 0x71, 0x8c, 0xc6, 0xd3, 0xcf, 0x0b, 0xc4, 0xcb, 0x78, 0x29, 0x16, 0x71, 0x40, + 0x93, 0x1a, 0xdb, 0x42, 0x06, 0xef, 0x78, 0x63, 0x7f, 0x3a, 0xe0, 0xa9, 0x68, 0xdb, 0x2a, 0xb8, + 0x63, 0x95, 0xac, 0x0a, 0xee, 0x78, 0x6d, 0xaa, 0x2f, 0x09, 0xdc, 0x3a, 0x9e, 0x1f, 0x86, 0x1b, + 0xff, 0x49, 0x43, 0x33, 0x11, 0xd9, 0xa6, 0x92, 0x22, 0x13, 0xf5, 0xa5, 0x4a, 0x8a, 0x4c, 0x56, + 0x9e, 0x43, 0x86, 0x48, 0x54, 0x94, 0xe2, 0x5f, 0x69, 0x68, 0x5c, 0x8a, 0x3d, 0x5c, 0x50, 0x6a, + 0x37, 0xa4, 0x37, 0xb3, 0x17, 0x47, 0xb2, 0x01, 0x88, 0x0b, 0x02, 0xe2, 0x6b, 0xf8, 0x78, 0x2c, + 0x44, 0x29, 0x39, 0xf1, 0x5f, 0x34, 0x34, 0x3b, 0x20, 0x26, 0xf1, 0x35, 0x85, 0x8c, 0x96, 0xa0, + 0x51, 0xb3, 0xd7, 0x77, 0x65, 0x0b, 0x98, 0xaf, 0x0a, 0xcc, 0x17, 0xf1, 0x85, 0x20, 0xe6, 0xc1, + 0x2b, 0x37, 0xd6, 0xa6, 0x1f, 0x45, 0x14, 0x2e, 0xfe, 0x9b, 0x86, 0x66, 0x07, 0x84, 0xa4, 0x0a, + 0x93, 0x24, 0x25, 0xab, 0xc2, 0x24, 0x51, 0xb9, 0xea, 0xb7, 0x05, 0x93, 0x1b, 0xf8, 0x7a, 0xfc, + 0x1a, 0x2a, 0xd4, 0x4f, 0x74, 0x09, 0x8d, 0xc8, 0xe6, 0x1d, 0x4f, 0xda, 0xe0, 0x75, 0xc2, 0x23, + 0x92, 0x12, 0xab, 0xcd, 0xb7, 0x18, 0xb5, 0xab, 0xb2, 0x54, 0x25, 0xe8, 0x57, 0xbd, 0x20, 0x08, + 0xad, 0xe0, 0xe5, 0xc4, 0xa4, 0x68, 0xda, 0x76, 0x55, 0x72, 0x70, 0x01, 0xe8, 0xb7, 0x1a, 0x3a, + 0x2c, 0x9c, 0xb1, 0x88, 0x12, 0xc4, 0x37, 0x94, 0x63, 0x1b, 0x27, 0x4b, 0xb3, 0x6f, 0xed, 0xd6, + 0x1c, 0xc8, 0x6c, 0x08, 0x32, 0x25, 0x7c, 0x2b, 0xbd, 0x77, 0xe4, 0x14, 0x36, 0x9d, 0x86, 0xbc, + 0x3e, 0x08, 0xac, 0x54, 0xc6, 0xb6, 0x28, 0xd9, 0xc1, 0x5f, 0x6a, 0xe8, 0x60, 0xe8, 0x20, 0x1a, + 0xff, 0x9f, 0xd2, 0x64, 0x1d, 0x38, 0xcf, 0xcf, 0x5e, 0x1e, 0xd9, 0x0e, 0xc8, 0xdc, 0x14, 0x64, + 0xae, 0xe2, 0xcb, 0x89, 0x3d, 0xc3, 0x19, 0xf3, 0xf5, 0xa6, 0xb1, 0x1d, 0x3d, 0x65, 0xdf, 0xc1, + 0xbf, 0xde, 0x8f, 0x72, 0xe9, 0x87, 0xe9, 0x78, 0x7d, 0x44, 0x70, 0x49, 0x57, 0x03, 0xd9, 0x8d, + 0x17, 0x77, 0x04, 0xb4, 0x6b, 0x82, 0xf6, 0xf7, 0xf0, 0x63, 0x15, 0xda, 0xd5, 0xb6, 0x38, 0x73, + 0xb7, 0xea, 0xa6, 0x6d, 0x6c, 0xc7, 0xde, 0x4d, 0xec, 0xc4, 0x45, 0xe6, 0x53, 0x4d, 0xdc, 0xdd, + 0x60, 0x43, 0x0d, 0x75, 0xef, 0x2a, 0x28, 0x7b, 0x5e, 0xdd, 0x00, 0xe8, 0xcc, 0x0b, 0x3a, 0x59, + 0x7c, 0x2c, 0x96, 0x8e, 0x07, 0xe2, 0xb7, 0x1a, 0x42, 0xfd, 0xdb, 0x03, 0xac, 0xb0, 0x28, 0x0c, + 0x5c, 0x67, 0x64, 0x2f, 0x8d, 0x66, 0x04, 0xd8, 0xce, 0x08, 0x6c, 0xa7, 0xf0, 0xc9, 0x58, 0x6c, + 0xbc, 0x8f, 0xe9, 0x73, 0x0d, 0x65, 0x42, 0xd7, 0x67, 0x9e, 0xae, 0x50, 0x4b, 0x3a, 0x71, 0x17, + 0xa6, 0xd9, 0x6b, 0xbb, 0x31, 0x05, 0xd0, 0xcb, 0x02, 0xf4, 0x69, 0xac, 0xc7, 0x82, 0x0e, 0xdf, + 0x6a, 0xfe, 0x55, 0x43, 0x73, 0x71, 0x37, 0x89, 0x2a, 0x79, 0x2a, 0xe5, 0x02, 0x53, 0x25, 0x4f, + 0xa5, 0x5d, 0x60, 0xea, 0x6f, 0x08, 0x0e, 0x06, 0x5e, 0x1d, 0xce, 0x21, 0x28, 0xa3, 0x3f, 0xd7, + 0x42, 0x77, 0xe4, 0xa3, 0x68, 0xe8, 0x70, 0xfc, 0xaf, 0x8c, 0x6e, 0x08, 0xc8, 0x2f, 0x0a, 0xe4, + 0xab, 0xf8, 0x5c, 0xbc, 0x40, 0xea, 0x5b, 0x04, 0x71, 0x7b, 0xa2, 0x34, 0xe0, 0x4c, 0x5d, 0x94, + 0xee, 0x0e, 0x7a, 0xfc, 0x07, 0x06, 0x43, 0x44, 0x69, 0x00, 0xba, 0xa7, 0x9e, 0xe6, 0xe2, 0xbe, + 0x20, 0x51, 0x19, 0x36, 0x29, 0x5f, 0xae, 0xa8, 0x0c, 0x9b, 0xb4, 0x0f, 0x57, 0x86, 0x6c, 0x07, + 0x5a, 0x22, 0xbf, 0x86, 0xac, 0xf1, 0x3f, 0x34, 0x74, 0x34, 0xe1, 0xdb, 0x1e, 0x7c, 0x6b, 0x77, + 0x68, 0xfa, 0x9f, 0x0f, 0x65, 0x8b, 0x2f, 0xe0, 0x01, 0x28, 0x5d, 0x12, 0x94, 0xf2, 0x78, 0x25, + 0x89, 0x52, 0xd1, 0xb6, 0xa3, 0x3e, 0x18, 0xfe, 0x42, 0x43, 0x99, 0xe8, 0xb7, 0x50, 0x2a, 0xf9, + 0x28, 0xe1, 0x93, 0x2d, 0x95, 0x7c, 0x94, 0xf4, 0x31, 0xd7, 0x90, 0x2d, 0x43, 0xf4, 0xcb, 0xac, + 0xd2, 0x9d, 0xaf, 0x9e, 0xe5, 0xb4, 0xaf, 0x9f, 0xe5, 0xb4, 0x6f, 0x9f, 0xe5, 0xb4, 0x5f, 0x3c, + 0xcf, 0xed, 0xfb, 0xfa, 0x79, 0x6e, 0xdf, 0xbf, 0x9e, 0xe7, 0xf6, 0x3d, 0x3e, 0xd7, 0xb2, 0x78, + 0x7b, 0xab, 0x96, 0xaf, 0xd3, 0xcd, 0xa0, 0x2b, 0x6f, 0xb7, 0x64, 0x7c, 0x1c, 0x48, 0xcb, 0xdd, + 0x0e, 0x61, 0xb5, 0x71, 0xf1, 0x2d, 0xda, 0xc5, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0xb3, 0x8c, + 0xf5, 0xdd, 0xb0, 0x29, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -2502,6 +2589,8 @@ type QueryClient interface { TssFundsMigratorInfo(ctx context.Context, in *QueryTssFundsMigratorInfoRequest, opts ...grpc.CallOption) (*QueryTssFundsMigratorInfoResponse, error) // Queries all TssFundMigratorInfo TssFundsMigratorInfoAll(ctx context.Context, in *QueryTssFundsMigratorInfoAllRequest, opts ...grpc.CallOption) (*QueryTssFundsMigratorInfoAllResponse, error) + // Queries operational flags + OperationalFlags(ctx context.Context, in *QueryOperationalFlagsRequest, opts ...grpc.CallOption) (*QueryOperationalFlagsResponse, error) } type queryClient struct { @@ -2728,6 +2817,15 @@ func (c *queryClient) TssFundsMigratorInfoAll(ctx context.Context, in *QueryTssF return out, nil } +func (c *queryClient) OperationalFlags(ctx context.Context, in *QueryOperationalFlagsRequest, opts ...grpc.CallOption) (*QueryOperationalFlagsResponse, error) { + out := new(QueryOperationalFlagsResponse) + err := c.cc.Invoke(ctx, "/zetachain.zetacore.observer.Query/OperationalFlags", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // QueryServer is the server API for Query service. type QueryServer interface { // Query if a voter has voted for a ballot @@ -2772,6 +2870,8 @@ type QueryServer interface { TssFundsMigratorInfo(context.Context, *QueryTssFundsMigratorInfoRequest) (*QueryTssFundsMigratorInfoResponse, error) // Queries all TssFundMigratorInfo TssFundsMigratorInfoAll(context.Context, *QueryTssFundsMigratorInfoAllRequest) (*QueryTssFundsMigratorInfoAllResponse, error) + // Queries operational flags + OperationalFlags(context.Context, *QueryOperationalFlagsRequest) (*QueryOperationalFlagsResponse, error) } // UnimplementedQueryServer can be embedded to have forward compatible implementations. @@ -2850,6 +2950,9 @@ func (*UnimplementedQueryServer) TssFundsMigratorInfo(ctx context.Context, req * func (*UnimplementedQueryServer) TssFundsMigratorInfoAll(ctx context.Context, req *QueryTssFundsMigratorInfoAllRequest) (*QueryTssFundsMigratorInfoAllResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method TssFundsMigratorInfoAll not implemented") } +func (*UnimplementedQueryServer) OperationalFlags(ctx context.Context, req *QueryOperationalFlagsRequest) (*QueryOperationalFlagsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method OperationalFlags not implemented") +} func RegisterQueryServer(s grpc1.Server, srv QueryServer) { s.RegisterService(&_Query_serviceDesc, srv) @@ -3287,6 +3390,24 @@ func _Query_TssFundsMigratorInfoAll_Handler(srv interface{}, ctx context.Context return interceptor(ctx, in, info, handler) } +func _Query_OperationalFlags_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryOperationalFlagsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).OperationalFlags(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zetachain.zetacore.observer.Query/OperationalFlags", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).OperationalFlags(ctx, req.(*QueryOperationalFlagsRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _Query_serviceDesc = grpc.ServiceDesc{ ServiceName: "zetachain.zetacore.observer.Query", HandlerType: (*QueryServer)(nil), @@ -3387,11 +3508,71 @@ var _Query_serviceDesc = grpc.ServiceDesc{ MethodName: "TssFundsMigratorInfoAll", Handler: _Query_TssFundsMigratorInfoAll_Handler, }, + { + MethodName: "OperationalFlags", + Handler: _Query_OperationalFlags_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "zetachain/zetacore/observer/query.proto", } +func (m *QueryOperationalFlagsRequest) 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 *QueryOperationalFlagsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryOperationalFlagsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryOperationalFlagsResponse) 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 *QueryOperationalFlagsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryOperationalFlagsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.OperationalFlags.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func (m *QueryTssFundsMigratorInfoAllRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -5054,6 +5235,26 @@ func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } +func (m *QueryOperationalFlagsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryOperationalFlagsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.OperationalFlags.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + func (m *QueryTssFundsMigratorInfoAllRequest) Size() (n int) { if m == nil { return 0 @@ -5718,6 +5919,139 @@ func sovQuery(x uint64) (n int) { func sozQuery(x uint64) (n int) { return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } +func (m *QueryOperationalFlagsRequest) 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: QueryOperationalFlagsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryOperationalFlagsRequest: 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 *QueryOperationalFlagsResponse) 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: QueryOperationalFlagsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryOperationalFlagsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OperationalFlags", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.OperationalFlags.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *QueryTssFundsMigratorInfoAllRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/x/observer/types/query.pb.gw.go b/x/observer/types/query.pb.gw.go index f3b98ac8b9..48bd9447dd 100644 --- a/x/observer/types/query.pb.gw.go +++ b/x/observer/types/query.pb.gw.go @@ -999,6 +999,24 @@ func local_request_Query_TssFundsMigratorInfoAll_0(ctx context.Context, marshale } +func request_Query_OperationalFlags_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryOperationalFlagsRequest + var metadata runtime.ServerMetadata + + msg, err := client.OperationalFlags(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_OperationalFlags_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryOperationalFlagsRequest + var metadata runtime.ServerMetadata + + msg, err := server.OperationalFlags(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. @@ -1557,6 +1575,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) + mux.Handle("GET", pattern_Query_OperationalFlags_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_OperationalFlags_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_OperationalFlags_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -2078,6 +2119,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) + mux.Handle("GET", pattern_Query_OperationalFlags_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_OperationalFlags_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_OperationalFlags_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -2129,6 +2190,8 @@ var ( pattern_Query_TssFundsMigratorInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"zeta-chain", "observer", "getTssFundsMigrator"}, "", runtime.AssumeColonVerbOpt(false))) pattern_Query_TssFundsMigratorInfoAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"zeta-chain", "observer", "getAllTssFundsMigrators"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Query_OperationalFlags_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"zeta-chain", "observer", "operationalFlags"}, "", runtime.AssumeColonVerbOpt(false))) ) var ( @@ -2179,4 +2242,6 @@ var ( forward_Query_TssFundsMigratorInfo_0 = runtime.ForwardResponseMessage forward_Query_TssFundsMigratorInfoAll_0 = runtime.ForwardResponseMessage + + forward_Query_OperationalFlags_0 = runtime.ForwardResponseMessage ) diff --git a/x/observer/types/tx.pb.go b/x/observer/types/tx.pb.go index d95a91e2ee..7ea1ae4086 100644 --- a/x/observer/types/tx.pb.go +++ b/x/observer/types/tx.pb.go @@ -1240,6 +1240,94 @@ func (m *MsgUpdateGasPriceIncreaseFlagsResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgUpdateGasPriceIncreaseFlagsResponse proto.InternalMessageInfo +type MsgUpdateOperationalFlags struct { + Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"` + OperationalFlags OperationalFlags `protobuf:"bytes,2,opt,name=operationalFlags,proto3" json:"operationalFlags"` +} + +func (m *MsgUpdateOperationalFlags) Reset() { *m = MsgUpdateOperationalFlags{} } +func (m *MsgUpdateOperationalFlags) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateOperationalFlags) ProtoMessage() {} +func (*MsgUpdateOperationalFlags) Descriptor() ([]byte, []int) { + return fileDescriptor_eda6e3b1d16a4021, []int{24} +} +func (m *MsgUpdateOperationalFlags) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateOperationalFlags) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateOperationalFlags.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 *MsgUpdateOperationalFlags) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateOperationalFlags.Merge(m, src) +} +func (m *MsgUpdateOperationalFlags) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateOperationalFlags) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateOperationalFlags.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateOperationalFlags proto.InternalMessageInfo + +func (m *MsgUpdateOperationalFlags) GetCreator() string { + if m != nil { + return m.Creator + } + return "" +} + +func (m *MsgUpdateOperationalFlags) GetOperationalFlags() OperationalFlags { + if m != nil { + return m.OperationalFlags + } + return OperationalFlags{} +} + +type MsgUpdateOperationalFlagsResponse struct { +} + +func (m *MsgUpdateOperationalFlagsResponse) Reset() { *m = MsgUpdateOperationalFlagsResponse{} } +func (m *MsgUpdateOperationalFlagsResponse) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateOperationalFlagsResponse) ProtoMessage() {} +func (*MsgUpdateOperationalFlagsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_eda6e3b1d16a4021, []int{25} +} +func (m *MsgUpdateOperationalFlagsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateOperationalFlagsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateOperationalFlagsResponse.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 *MsgUpdateOperationalFlagsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateOperationalFlagsResponse.Merge(m, src) +} +func (m *MsgUpdateOperationalFlagsResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateOperationalFlagsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateOperationalFlagsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateOperationalFlagsResponse proto.InternalMessageInfo + func init() { proto.RegisterType((*MsgUpdateObserver)(nil), "zetachain.zetacore.observer.MsgUpdateObserver") proto.RegisterType((*MsgUpdateObserverResponse)(nil), "zetachain.zetacore.observer.MsgUpdateObserverResponse") @@ -1265,6 +1353,8 @@ func init() { proto.RegisterType((*MsgDisableCCTXResponse)(nil), "zetachain.zetacore.observer.MsgDisableCCTXResponse") proto.RegisterType((*MsgUpdateGasPriceIncreaseFlags)(nil), "zetachain.zetacore.observer.MsgUpdateGasPriceIncreaseFlags") proto.RegisterType((*MsgUpdateGasPriceIncreaseFlagsResponse)(nil), "zetachain.zetacore.observer.MsgUpdateGasPriceIncreaseFlagsResponse") + proto.RegisterType((*MsgUpdateOperationalFlags)(nil), "zetachain.zetacore.observer.MsgUpdateOperationalFlags") + proto.RegisterType((*MsgUpdateOperationalFlagsResponse)(nil), "zetachain.zetacore.observer.MsgUpdateOperationalFlagsResponse") } func init() { @@ -1272,86 +1362,91 @@ func init() { } var fileDescriptor_eda6e3b1d16a4021 = []byte{ - // 1262 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0x4b, 0x6f, 0xdb, 0xc6, - 0x13, 0x37, 0xff, 0xce, 0xc3, 0x1e, 0x59, 0xb2, 0xc3, 0xbf, 0x93, 0xc8, 0x74, 0xa3, 0x06, 0x44, - 0xe2, 0x28, 0x8f, 0x4a, 0xb1, 0x52, 0xf4, 0x79, 0xf2, 0x23, 0xb1, 0xdd, 0xd4, 0xb1, 0x41, 0xb9, - 0x41, 0x91, 0x0b, 0xb1, 0x22, 0xd7, 0x14, 0x6b, 0x6a, 0x57, 0xe0, 0x52, 0x7e, 0xa4, 0x41, 0x81, - 0x1e, 0x0b, 0xf4, 0xd0, 0x0f, 0x50, 0xa0, 0xf7, 0x7e, 0x83, 0xf6, 0xdc, 0x43, 0x7a, 0xcb, 0xb1, - 0xa7, 0xa2, 0xb0, 0x4f, 0xfd, 0x16, 0x05, 0x77, 0x97, 0xab, 0xa7, 0x29, 0x29, 0x45, 0x4f, 0x12, - 0x67, 0x7f, 0xbf, 0x99, 0xdf, 0xec, 0xce, 0xce, 0x90, 0x70, 0xeb, 0x25, 0x8e, 0x90, 0x53, 0x47, - 0x3e, 0x29, 0xf3, 0x7f, 0x34, 0xc4, 0x65, 0x5a, 0x63, 0x38, 0x3c, 0xc4, 0x61, 0x39, 0x3a, 0x2e, - 0x35, 0x43, 0x1a, 0x51, 0x7d, 0x51, 0xa1, 0x4a, 0x09, 0xaa, 0x94, 0xa0, 0x8c, 0x79, 0x8f, 0x7a, - 0x94, 0xe3, 0xca, 0xf1, 0x3f, 0x41, 0x31, 0xee, 0xa4, 0x39, 0xae, 0x05, 0xa8, 0x81, 0x25, 0xb0, - 0x92, 0x06, 0x74, 0x42, 0xca, 0x18, 0x5f, 0xb4, 0xf7, 0x03, 0xe4, 0x31, 0xc9, 0xb9, 0x97, 0xc6, - 0x49, 0xfe, 0x48, 0x6c, 0x31, 0x0d, 0xdb, 0x44, 0x21, 0x6a, 0x24, 0x5e, 0x1f, 0xa6, 0x22, 0x31, - 0x71, 0x7d, 0xe2, 0xd9, 0x84, 0x12, 0x07, 0x27, 0x8c, 0xdb, 0xa9, 0xbb, 0xc7, 0xd2, 0xe4, 0x36, - 0x0f, 0xbc, 0x32, 0x37, 0x31, 0xf9, 0x33, 0x04, 0xdb, 0x0c, 0x29, 0xdd, 0x67, 0xf2, 0x47, 0x60, - 0xcd, 0xbf, 0x35, 0xb8, 0xb2, 0xcd, 0xbc, 0x2f, 0x9a, 0x2e, 0x8a, 0xf0, 0x8e, 0x8c, 0xab, 0xe7, - 0xe1, 0xb2, 0x13, 0x62, 0x14, 0xd1, 0x30, 0xaf, 0xdd, 0xd4, 0x8a, 0xd3, 0x56, 0xf2, 0xa8, 0x3f, - 0x84, 0x79, 0x1a, 0xb8, 0x76, 0xa2, 0xd0, 0x46, 0xae, 0x1b, 0x62, 0xc6, 0xf2, 0xff, 0xe3, 0x30, - 0x9d, 0x06, 0x6e, 0xe2, 0x64, 0x45, 0xac, 0xc4, 0x0c, 0x82, 0x8f, 0xfa, 0x19, 0x93, 0x82, 0x41, - 0xf0, 0x51, 0x2f, 0xe3, 0x39, 0x64, 0x5b, 0x5c, 0x8f, 0x1d, 0x62, 0xc4, 0x28, 0xc9, 0x5f, 0xb8, - 0xa9, 0x15, 0x73, 0x95, 0xe5, 0x52, 0x4a, 0x09, 0x95, 0x12, 0x27, 0x22, 0x13, 0x8b, 0x13, 0xad, - 0x99, 0x56, 0xc7, 0x93, 0xb9, 0x08, 0x0b, 0x7d, 0xa9, 0x5a, 0x98, 0x35, 0x29, 0x61, 0xd8, 0xfc, - 0x5d, 0x03, 0x7d, 0x9b, 0x79, 0xcf, 0x69, 0x84, 0x57, 0x03, 0xea, 0x1c, 0x6c, 0x62, 0xe4, 0xa6, - 0xee, 0xc4, 0x02, 0x4c, 0x89, 0xaa, 0xf2, 0x5d, 0x9e, 0xfd, 0xa4, 0x75, 0x99, 0x3f, 0x6f, 0xb9, - 0xfa, 0x0d, 0x80, 0x5a, 0xec, 0xc3, 0xae, 0x23, 0x56, 0xe7, 0x89, 0xce, 0x58, 0xd3, 0xdc, 0xb2, - 0x89, 0x58, 0x5d, 0xbf, 0x06, 0x97, 0xea, 0xd8, 0xf7, 0xea, 0x11, 0x4f, 0x6c, 0xd2, 0x92, 0x4f, - 0xfa, 0x46, 0x6c, 0x8f, 0xa3, 0xe6, 0x2f, 0xde, 0xd4, 0x8a, 0x99, 0xca, 0xdd, 0x41, 0x09, 0x37, - 0x0f, 0xbc, 0x92, 0x3c, 0x41, 0x21, 0x71, 0x1d, 0x45, 0x68, 0xf5, 0xc2, 0xeb, 0x3f, 0xdf, 0x9d, - 0xb0, 0x24, 0xdd, 0xfc, 0x0a, 0x8c, 0xfe, 0x54, 0x92, 0x4c, 0xf5, 0xdb, 0x90, 0xab, 0xa1, 0x20, - 0xa0, 0x91, 0xcd, 0x53, 0xc1, 0x2e, 0xcf, 0x6c, 0xca, 0xca, 0x0a, 0xeb, 0x9a, 0x30, 0xc6, 0xb0, - 0x43, 0x1a, 0x61, 0x7b, 0xdf, 0x27, 0x28, 0xf0, 0x5f, 0x62, 0x91, 0xe5, 0x94, 0x95, 0x8d, 0xad, - 0x4f, 0x12, 0xa3, 0xf9, 0x0a, 0xe6, 0xd5, 0xa6, 0xae, 0xc5, 0x52, 0x77, 0xf9, 0x7d, 0x48, 0xd9, - 0xb8, 0xcf, 0x20, 0xe3, 0xb4, 0x81, 0xdc, 0x6b, 0xa6, 0x52, 0x4c, 0x3d, 0xdc, 0x0e, 0xc7, 0x56, - 0x27, 0xd9, 0x2c, 0xc0, 0x3b, 0x83, 0xa2, 0xab, 0x53, 0x7d, 0xca, 0xd5, 0x59, 0xb8, 0x41, 0x0f, - 0x47, 0x54, 0x77, 0xfe, 0xb1, 0xca, 0x60, 0x7d, 0xce, 0x54, 0xb0, 0xdf, 0x34, 0xc8, 0x6d, 0x33, - 0x6f, 0xc5, 0x75, 0x47, 0xb8, 0x48, 0x77, 0x61, 0xee, 0x9c, 0x4b, 0x34, 0x4b, 0x7b, 0xee, 0xc3, - 0x27, 0xb0, 0xc0, 0xb7, 0x24, 0xf0, 0x31, 0x89, 0x6c, 0x2f, 0x44, 0x24, 0xc2, 0xd8, 0x6e, 0xb6, - 0x6a, 0x07, 0xf8, 0x44, 0x5e, 0xa3, 0xeb, 0x6d, 0xc0, 0x86, 0x58, 0xdf, 0xe5, 0xcb, 0xfa, 0x32, - 0x5c, 0x45, 0xae, 0x6b, 0x13, 0xea, 0x62, 0x1b, 0x39, 0x0e, 0x6d, 0x91, 0xc8, 0xa6, 0x24, 0x38, - 0xe1, 0xa5, 0x37, 0x65, 0xe9, 0xc8, 0x75, 0x9f, 0x51, 0x17, 0xaf, 0x88, 0xa5, 0x1d, 0x12, 0x9c, - 0x98, 0x79, 0xb8, 0xd6, 0x9d, 0x85, 0x4a, 0xf0, 0x7b, 0x0d, 0x66, 0x54, 0x61, 0xa1, 0x06, 0x7e, - 0xbb, 0xdb, 0xb1, 0x11, 0xdf, 0x0e, 0xd4, 0xc0, 0xb6, 0x4f, 0xf6, 0x29, 0xd7, 0x9f, 0xa9, 0x98, - 0xa9, 0xc7, 0xcf, 0x83, 0xc9, 0x1a, 0x9f, 0xe6, 0xdc, 0x2d, 0xb2, 0x4f, 0xcd, 0x6b, 0xfc, 0x70, - 0x95, 0x1a, 0x25, 0x73, 0x05, 0x66, 0x55, 0x51, 0x3c, 0xc5, 0x27, 0x1e, 0x26, 0x29, 0x42, 0xe7, - 0xe1, 0x22, 0xbf, 0x99, 0x52, 0xa5, 0x78, 0x30, 0x17, 0xe0, 0x7a, 0x8f, 0x0b, 0xe5, 0xfd, 0x47, - 0x0d, 0xfe, 0xcf, 0xcb, 0x80, 0xe1, 0x88, 0x57, 0xc1, 0x33, 0xde, 0xce, 0xdf, 0x6e, 0x2f, 0x96, - 0x60, 0x56, 0x2c, 0xf1, 0x99, 0x60, 0x07, 0xf4, 0x88, 0x6f, 0xc8, 0xa4, 0x95, 0x75, 0x94, 0xeb, - 0xcf, 0xe9, 0x91, 0x5e, 0x84, 0xb9, 0x4e, 0x5c, 0xdd, 0xf7, 0xea, 0xb2, 0x79, 0xe4, 0xda, 0xc0, - 0x4d, 0xdf, 0xab, 0x9b, 0x37, 0x60, 0x71, 0x80, 0x3a, 0xa5, 0xfe, 0x17, 0x0d, 0x40, 0x6e, 0xda, - 0x5e, 0xb5, 0x9a, 0x22, 0xfa, 0x06, 0x40, 0xc4, 0x58, 0x52, 0x65, 0xa2, 0x32, 0xa7, 0x23, 0xc6, - 0x64, 0x5d, 0x3d, 0x00, 0xfd, 0x80, 0xef, 0x8b, 0x1d, 0x1f, 0x97, 0x2d, 0xfb, 0x99, 0xd0, 0x3e, - 0x27, 0x56, 0x5e, 0xe0, 0x08, 0x6d, 0x8a, 0xce, 0xb6, 0x0e, 0x97, 0x58, 0x84, 0xa2, 0x16, 0x93, - 0xad, 0xfc, 0xc1, 0x79, 0x9d, 0x4d, 0xce, 0x31, 0x0b, 0x3b, 0xd8, 0x3f, 0xc4, 0x55, 0xce, 0xb1, - 0x24, 0xd7, 0xfc, 0xae, 0xdd, 0xa2, 0xf7, 0xaa, 0xd5, 0xff, 0xa6, 0x9f, 0xc5, 0x30, 0x99, 0x18, - 0x6b, 0x39, 0x4e, 0x32, 0xa8, 0xa6, 0xac, 0xac, 0xb0, 0x56, 0x85, 0xd1, 0x3c, 0x82, 0xec, 0x36, - 0xf3, 0x1e, 0x13, 0x54, 0x0b, 0xf0, 0xda, 0xda, 0xde, 0x97, 0x29, 0x3b, 0x79, 0x0b, 0xb2, 0x98, - 0xe3, 0xb6, 0x48, 0x8d, 0xb6, 0x88, 0x8a, 0xdb, 0x65, 0xd4, 0x97, 0x20, 0x27, 0x0c, 0x3b, 0xad, - 0x48, 0xc0, 0x44, 0xdc, 0x1e, 0xab, 0x79, 0x1d, 0xae, 0x76, 0x05, 0x56, 0x27, 0xfb, 0x8a, 0x37, - 0x9f, 0x75, 0x9f, 0x8d, 0x20, 0x69, 0x09, 0x72, 0xae, 0x00, 0x76, 0x6b, 0xea, 0xb1, 0xea, 0x45, - 0x98, 0x95, 0x96, 0x1e, 0x55, 0xbd, 0x66, 0xd9, 0x34, 0x3a, 0xa2, 0x2b, 0x5d, 0x3f, 0x6b, 0x50, - 0x50, 0x77, 0x69, 0x03, 0xb1, 0xdd, 0xd0, 0x77, 0xf0, 0x16, 0x89, 0xa5, 0x30, 0xfc, 0x24, 0x7e, - 0x23, 0x4b, 0x11, 0x4a, 0xe0, 0xaa, 0x37, 0x88, 0x22, 0xa7, 0x46, 0x25, 0xb5, 0x6d, 0x0c, 0x0c, - 0x26, 0xdb, 0xc8, 0x60, 0xb7, 0x66, 0x11, 0x96, 0xd2, 0xb5, 0x26, 0x69, 0x55, 0x7e, 0xcd, 0xc0, - 0xe4, 0x36, 0xf3, 0x74, 0x0a, 0x99, 0xce, 0x86, 0x7f, 0x3f, 0x55, 0x51, 0x77, 0x5f, 0x35, 0x1e, - 0x8d, 0x01, 0x56, 0xe5, 0x7e, 0x0c, 0xb9, 0x9e, 0xb7, 0xb5, 0xd2, 0x30, 0x37, 0xdd, 0x78, 0xe3, - 0x83, 0xf1, 0xf0, 0x2a, 0xf2, 0xb7, 0x1a, 0x5c, 0xe9, 0x1f, 0xf4, 0xcb, 0xa3, 0x79, 0xeb, 0xa0, - 0x18, 0x1f, 0x8f, 0x4d, 0xe9, 0xd2, 0xd0, 0x3f, 0xce, 0x87, 0x6a, 0xe8, 0xa3, 0x0c, 0xd7, 0x70, - 0xee, 0x9c, 0xd7, 0x7d, 0x98, 0x6e, 0x8f, 0xc0, 0xbb, 0xc3, 0xfc, 0x28, 0xa8, 0xb1, 0x3c, 0x32, - 0x54, 0x85, 0x0a, 0x61, 0xa6, 0x6b, 0x8e, 0x3d, 0x18, 0x6d, 0xe7, 0x04, 0xda, 0x78, 0x7f, 0x1c, - 0xb4, 0x8a, 0xf9, 0x35, 0xcc, 0xf6, 0xbe, 0x05, 0x97, 0x47, 0x53, 0xae, 0x08, 0xc6, 0x87, 0x63, - 0x12, 0x54, 0xf0, 0x6f, 0x60, 0xae, 0x6f, 0xb2, 0x3e, 0x1c, 0x7e, 0x54, 0xdd, 0x0c, 0xe3, 0xa3, - 0x71, 0x19, 0x2a, 0xbe, 0x03, 0x97, 0x93, 0xd9, 0x78, 0x67, 0x94, 0x1c, 0xf6, 0xaa, 0x55, 0xa3, - 0x3c, 0x22, 0x50, 0x05, 0x09, 0x00, 0x3a, 0x26, 0xc7, 0xbd, 0x61, 0xf4, 0x36, 0xd6, 0xa8, 0x8c, - 0x8e, 0x55, 0xd1, 0x28, 0x64, 0x3a, 0xa7, 0xc2, 0xd0, 0x0e, 0xd5, 0x01, 0x1e, 0xde, 0xa1, 0x06, - 0x74, 0x7c, 0xfd, 0x27, 0x0d, 0x16, 0xd3, 0xda, 0xfd, 0xa7, 0xa3, 0x95, 0xe5, 0x40, 0xb2, 0xb1, - 0xf6, 0x2f, 0xc8, 0x89, 0xc2, 0xd5, 0xc7, 0xaf, 0x4f, 0x0b, 0xda, 0x9b, 0xd3, 0x82, 0xf6, 0xd7, - 0x69, 0x41, 0xfb, 0xe1, 0xac, 0x30, 0xf1, 0xe6, 0xac, 0x30, 0xf1, 0xc7, 0x59, 0x61, 0xe2, 0xc5, - 0x7d, 0xcf, 0x8f, 0xea, 0xad, 0x5a, 0xc9, 0xa1, 0x0d, 0xfe, 0xf1, 0xfc, 0x9e, 0xf8, 0x8e, 0x8e, - 0xdf, 0x9f, 0xcb, 0xc7, 0x1d, 0x1f, 0xe6, 0x27, 0x4d, 0xcc, 0x6a, 0x97, 0xf8, 0x37, 0xf4, 0xa3, - 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x65, 0x57, 0x89, 0x92, 0x02, 0x11, 0x00, 0x00, + // 1332 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0xcb, 0x6f, 0xdb, 0xc6, + 0x13, 0x36, 0x7f, 0xce, 0xc3, 0x1e, 0x5b, 0xb2, 0xc3, 0x9f, 0xe3, 0xd8, 0x74, 0xa3, 0xa6, 0x6c, + 0xe2, 0x28, 0x2f, 0x29, 0x56, 0x8a, 0x3e, 0x81, 0x02, 0x8e, 0x93, 0xd8, 0x6e, 0xea, 0x24, 0xa0, + 0xdc, 0xa0, 0xc8, 0x85, 0x58, 0x91, 0x6b, 0x8a, 0x35, 0xbd, 0x2b, 0x70, 0x29, 0x3b, 0x4e, 0x83, + 0x02, 0x3d, 0x16, 0xe8, 0x21, 0xa7, 0x9e, 0x0a, 0xf4, 0xde, 0xff, 0xa0, 0xf7, 0x1e, 0xd2, 0x43, + 0x81, 0x1c, 0x7b, 0x2a, 0x8a, 0xe4, 0xd4, 0xff, 0xa2, 0xe0, 0xee, 0x72, 0x25, 0x51, 0x32, 0x45, + 0xb9, 0xe8, 0x49, 0xe4, 0xec, 0xf7, 0xcd, 0x7c, 0xb3, 0x8f, 0x99, 0x15, 0xe1, 0xe2, 0x33, 0x1c, + 0x21, 0xa7, 0x89, 0x7c, 0x52, 0xe5, 0x4f, 0x34, 0xc4, 0x55, 0xda, 0x60, 0x38, 0xdc, 0xc7, 0x61, + 0x35, 0x7a, 0x5a, 0x69, 0x85, 0x34, 0xa2, 0xfa, 0x92, 0x42, 0x55, 0x12, 0x54, 0x25, 0x41, 0x19, + 0x73, 0x1e, 0xf5, 0x28, 0xc7, 0x55, 0xe3, 0x27, 0x41, 0x31, 0x2e, 0x67, 0x39, 0x6e, 0x04, 0x68, + 0x0f, 0x4b, 0x60, 0x2d, 0x0b, 0xe8, 0x84, 0x94, 0x31, 0x3e, 0x68, 0xef, 0x04, 0xc8, 0x63, 0x92, + 0x73, 0x35, 0x8b, 0x93, 0x3c, 0x48, 0x6c, 0x39, 0x0b, 0xdb, 0x42, 0x21, 0xda, 0x4b, 0xbc, 0xde, + 0xcc, 0x44, 0x62, 0xe2, 0xfa, 0xc4, 0xb3, 0x09, 0x25, 0x0e, 0x4e, 0x18, 0x97, 0x32, 0x67, 0x8f, + 0x25, 0xb0, 0x1b, 0x99, 0x72, 0x5b, 0x38, 0x44, 0x91, 0x4f, 0x09, 0x0a, 0x32, 0xb2, 0x6b, 0xed, + 0x7a, 0x55, 0x6e, 0x62, 0xf2, 0x67, 0x08, 0xb6, 0x15, 0x52, 0xba, 0xc3, 0xe4, 0x8f, 0xc0, 0x9a, + 0x7f, 0x6b, 0x70, 0x66, 0x8b, 0x79, 0x5f, 0xb4, 0x5c, 0x14, 0xe1, 0x87, 0x32, 0xbe, 0xbe, 0x00, + 0xa7, 0x9d, 0x10, 0xa3, 0x88, 0x86, 0x0b, 0xda, 0x05, 0xad, 0x3c, 0x69, 0x25, 0xaf, 0xfa, 0x4d, + 0x98, 0xa3, 0x81, 0x6b, 0x27, 0x4a, 0x6d, 0xe4, 0xba, 0x21, 0x66, 0x6c, 0xe1, 0x7f, 0x1c, 0xa6, + 0xd3, 0xc0, 0x4d, 0x9c, 0xac, 0x8a, 0x91, 0x98, 0x41, 0xf0, 0x41, 0x3f, 0x63, 0x5c, 0x30, 0x08, + 0x3e, 0x48, 0x33, 0x1e, 0x43, 0xa1, 0xcd, 0xf5, 0xd8, 0x21, 0x46, 0x8c, 0x92, 0x85, 0x13, 0x17, + 0xb4, 0x72, 0xb1, 0xb6, 0x52, 0xc9, 0xd8, 0x71, 0x95, 0xc4, 0x89, 0xc8, 0xc4, 0xe2, 0x44, 0x6b, + 0xba, 0xdd, 0xf5, 0x66, 0x2e, 0xc1, 0x62, 0x5f, 0xaa, 0x16, 0x66, 0x2d, 0x4a, 0x18, 0x36, 0x7f, + 0xd3, 0x40, 0xdf, 0x62, 0xde, 0x63, 0x1a, 0xe1, 0xdb, 0x01, 0x75, 0x76, 0x37, 0x30, 0x72, 0x33, + 0x67, 0x62, 0x11, 0x26, 0xc4, 0x26, 0xf4, 0x5d, 0x9e, 0xfd, 0xb8, 0x75, 0x9a, 0xbf, 0x6f, 0xba, + 0xfa, 0x79, 0x80, 0x46, 0xec, 0xc3, 0x6e, 0x22, 0xd6, 0xe4, 0x89, 0x4e, 0x5b, 0x93, 0xdc, 0xb2, + 0x81, 0x58, 0x53, 0x9f, 0x87, 0x53, 0x4d, 0xec, 0x7b, 0xcd, 0x88, 0x27, 0x36, 0x6e, 0xc9, 0x37, + 0x7d, 0x3d, 0xb6, 0xc7, 0x51, 0x17, 0x4e, 0x5e, 0xd0, 0xca, 0x53, 0xb5, 0x2b, 0x83, 0x12, 0x6e, + 0xed, 0x7a, 0x15, 0xb9, 0x82, 0x42, 0xe2, 0x1d, 0x14, 0xa1, 0xdb, 0x27, 0x5e, 0xfe, 0xf9, 0xf6, + 0x98, 0x25, 0xe9, 0xe6, 0x57, 0x60, 0xf4, 0xa7, 0x92, 0x64, 0xaa, 0x5f, 0x82, 0x62, 0x03, 0x05, + 0x01, 0x8d, 0x6c, 0x9e, 0x0a, 0x76, 0x79, 0x66, 0x13, 0x56, 0x41, 0x58, 0xd7, 0x84, 0x31, 0x86, + 0xed, 0xd3, 0x08, 0xdb, 0x3b, 0x3e, 0x41, 0x81, 0xff, 0x0c, 0x8b, 0x2c, 0x27, 0xac, 0x42, 0x6c, + 0xbd, 0x97, 0x18, 0xcd, 0xe7, 0x30, 0xa7, 0x26, 0x75, 0x2d, 0x96, 0xfa, 0x88, 0x1f, 0x9f, 0x8c, + 0x89, 0xfb, 0x0c, 0xa6, 0x9c, 0x0e, 0x90, 0x7b, 0x9d, 0xaa, 0x95, 0x33, 0x17, 0xb7, 0xcb, 0xb1, + 0xd5, 0x4d, 0x36, 0x4b, 0xf0, 0xd6, 0xa0, 0xe8, 0x6a, 0x55, 0xef, 0x73, 0x75, 0x16, 0xde, 0xa3, + 0xfb, 0x39, 0xd5, 0x1d, 0xbd, 0xac, 0x32, 0x58, 0x9f, 0x33, 0x15, 0xec, 0x57, 0x0d, 0x8a, 0x5b, + 0xcc, 0x5b, 0x75, 0xdd, 0x1c, 0x07, 0xe9, 0x0a, 0xcc, 0x1e, 0x71, 0x88, 0x66, 0x68, 0xea, 0x3c, + 0x7c, 0x0c, 0x8b, 0x7c, 0x4a, 0x02, 0x1f, 0x93, 0xc8, 0xf6, 0x42, 0x44, 0x22, 0x8c, 0xed, 0x56, + 0xbb, 0xb1, 0x8b, 0x0f, 0xe5, 0x31, 0x3a, 0xd7, 0x01, 0xac, 0x8b, 0xf1, 0x47, 0x7c, 0x58, 0x5f, + 0x81, 0xb3, 0xc8, 0x75, 0x6d, 0x42, 0x5d, 0x6c, 0x23, 0xc7, 0xa1, 0x6d, 0x12, 0xd9, 0x94, 0x04, + 0x87, 0x7c, 0xeb, 0x4d, 0x58, 0x3a, 0x72, 0xdd, 0x07, 0xd4, 0xc5, 0xab, 0x62, 0xe8, 0x21, 0x09, + 0x0e, 0xcd, 0x05, 0x98, 0xef, 0xcd, 0x42, 0x25, 0xf8, 0xbd, 0x06, 0xd3, 0x6a, 0x63, 0xa1, 0x3d, + 0x7c, 0xbc, 0xd3, 0xb1, 0x1e, 0x9f, 0x0e, 0xb4, 0x87, 0x6d, 0x9f, 0xec, 0x50, 0xae, 0x7f, 0xaa, + 0x66, 0x66, 0x2e, 0x3f, 0x0f, 0x26, 0xf7, 0xf8, 0x24, 0xe7, 0x6e, 0x92, 0x1d, 0x6a, 0xce, 0xf3, + 0xc5, 0x55, 0x6a, 0x94, 0xcc, 0x55, 0x98, 0x51, 0x9b, 0xe2, 0x3e, 0x3e, 0xf4, 0x30, 0xc9, 0x10, + 0x3a, 0x07, 0x27, 0xf9, 0xc9, 0x94, 0x2a, 0xc5, 0x8b, 0xb9, 0x08, 0xe7, 0x52, 0x2e, 0x94, 0xf7, + 0x1f, 0x35, 0xf8, 0x3f, 0xdf, 0x06, 0x0c, 0x47, 0x7c, 0x17, 0x3c, 0xe0, 0xd5, 0xff, 0x78, 0x73, + 0xb1, 0x0c, 0x33, 0x62, 0x88, 0xb7, 0x10, 0x3b, 0xa0, 0x07, 0x7c, 0x42, 0xc6, 0xad, 0x82, 0xa3, + 0x5c, 0x7f, 0x4e, 0x0f, 0xf4, 0x32, 0xcc, 0x76, 0xe3, 0x9a, 0xbe, 0xd7, 0x94, 0xc5, 0xa3, 0xd8, + 0x01, 0x6e, 0xf8, 0x5e, 0xd3, 0x3c, 0x0f, 0x4b, 0x03, 0xd4, 0x29, 0xf5, 0xbf, 0x68, 0x00, 0x72, + 0xd2, 0xb6, 0xeb, 0xf5, 0x0c, 0xd1, 0xe7, 0x01, 0x22, 0xc6, 0x92, 0x5d, 0x26, 0x76, 0xe6, 0x64, + 0xc4, 0x98, 0xdc, 0x57, 0xd7, 0x41, 0xdf, 0xe5, 0xf3, 0x62, 0xc7, 0xcb, 0x65, 0xcb, 0x7a, 0x26, + 0xb4, 0xcf, 0x8a, 0x91, 0x27, 0x38, 0x42, 0x1b, 0xa2, 0xb2, 0xdd, 0x81, 0x53, 0x2c, 0x42, 0x51, + 0x9b, 0xc9, 0x52, 0x7e, 0xfd, 0xa8, 0xca, 0x26, 0xfb, 0x98, 0x85, 0x1d, 0xec, 0xef, 0xe3, 0x3a, + 0xe7, 0x58, 0x92, 0x6b, 0x7e, 0xd7, 0x29, 0xd1, 0xdb, 0xf5, 0xfa, 0x7f, 0x53, 0xcf, 0x62, 0x98, + 0x4c, 0x8c, 0xb5, 0x1d, 0x27, 0x69, 0x54, 0x13, 0x56, 0x41, 0x58, 0xeb, 0xc2, 0x68, 0x1e, 0x40, + 0x61, 0x8b, 0x79, 0x77, 0x09, 0x6a, 0x04, 0x78, 0x6d, 0x6d, 0xfb, 0xcb, 0x8c, 0x99, 0xbc, 0x08, + 0x05, 0xcc, 0x71, 0x9b, 0xa4, 0x41, 0xdb, 0x44, 0xc5, 0xed, 0x31, 0xea, 0xcb, 0x50, 0x14, 0x86, + 0x87, 0xed, 0x48, 0xc0, 0x44, 0xdc, 0x94, 0xd5, 0x3c, 0x07, 0x67, 0x7b, 0x02, 0xab, 0x95, 0x7d, + 0xce, 0x8b, 0xcf, 0x1d, 0x9f, 0xe5, 0x90, 0xb4, 0x0c, 0x45, 0x57, 0x00, 0x7b, 0x35, 0xa5, 0xac, + 0x7a, 0x19, 0x66, 0xa4, 0x25, 0xa5, 0x2a, 0x6d, 0x96, 0x45, 0xa3, 0x2b, 0xba, 0xd2, 0xf5, 0xb3, + 0x06, 0x25, 0x75, 0x96, 0xd6, 0x11, 0x7b, 0x14, 0xfa, 0x0e, 0xde, 0x24, 0xb1, 0x14, 0x86, 0xef, + 0xc5, 0x17, 0xb8, 0x0c, 0xa1, 0x04, 0xce, 0x7a, 0x83, 0x28, 0xb2, 0x6b, 0xd4, 0x32, 0xcb, 0xc6, + 0xc0, 0x60, 0xb2, 0x8c, 0x0c, 0x76, 0x6b, 0x96, 0x61, 0x39, 0x5b, 0xab, 0x4a, 0xeb, 0x07, 0xad, + 0xfb, 0x36, 0xd1, 0xb9, 0xaf, 0x0d, 0xcb, 0xc8, 0x86, 0x59, 0x9a, 0x42, 0xcb, 0x64, 0x6e, 0x64, + 0xdf, 0x6f, 0x52, 0x24, 0x99, 0x47, 0x9f, 0x33, 0xf3, 0x5d, 0x78, 0xe7, 0x48, 0x5d, 0x89, 0xfa, + 0xda, 0xef, 0xd3, 0x30, 0xbe, 0xc5, 0x3c, 0x9d, 0xc2, 0x54, 0x77, 0xbb, 0xba, 0x96, 0x29, 0xa1, + 0xb7, 0x2b, 0x18, 0xb7, 0x46, 0x00, 0xab, 0xc3, 0xfa, 0x14, 0x8a, 0xa9, 0xbb, 0x66, 0x65, 0x98, + 0x9b, 0x5e, 0xbc, 0xf1, 0xfe, 0x68, 0x78, 0x15, 0xf9, 0x5b, 0x0d, 0xce, 0xf4, 0x5f, 0x53, 0x56, + 0xf2, 0x79, 0xeb, 0xa2, 0x18, 0x1f, 0x8d, 0x4c, 0xe9, 0xd1, 0xd0, 0x7f, 0x19, 0x19, 0xaa, 0xa1, + 0x8f, 0x32, 0x5c, 0xc3, 0x91, 0xb7, 0x14, 0xdd, 0x87, 0xc9, 0x4e, 0x03, 0xbf, 0x32, 0xcc, 0x8f, + 0x82, 0x1a, 0x2b, 0xb9, 0xa1, 0x2a, 0x54, 0x08, 0xd3, 0x3d, 0x5d, 0xf8, 0x7a, 0xbe, 0x99, 0x13, + 0x68, 0xe3, 0xbd, 0x51, 0xd0, 0x2a, 0xe6, 0xd7, 0x30, 0x93, 0xbe, 0xc3, 0x57, 0xf3, 0x29, 0x57, + 0x04, 0xe3, 0x83, 0x11, 0x09, 0x2a, 0xf8, 0x37, 0x30, 0xdb, 0x77, 0x2f, 0xb8, 0x39, 0x7c, 0xa9, + 0x7a, 0x19, 0xc6, 0x87, 0xa3, 0x32, 0x54, 0x7c, 0x07, 0x4e, 0x27, 0x9d, 0xfd, 0x72, 0x9e, 0x1c, + 0xb6, 0xeb, 0x75, 0xa3, 0x9a, 0x13, 0xa8, 0x82, 0x04, 0x00, 0x5d, 0x7d, 0xef, 0xea, 0x30, 0x7a, + 0x07, 0x6b, 0xd4, 0xf2, 0x63, 0x55, 0x34, 0x0a, 0x53, 0xdd, 0x3d, 0x6d, 0x68, 0x85, 0xea, 0x02, + 0x0f, 0xaf, 0x50, 0x03, 0xfa, 0x95, 0xfe, 0x93, 0x06, 0x4b, 0x59, 0xcd, 0xea, 0x93, 0x7c, 0xdb, + 0x72, 0x20, 0xd9, 0x58, 0xfb, 0x17, 0x64, 0xa5, 0xf0, 0x85, 0x06, 0xf3, 0x47, 0xf4, 0x9d, 0xbc, + 0xc5, 0x31, 0xc5, 0x33, 0x3e, 0x3d, 0x1e, 0x2f, 0x91, 0x74, 0xfb, 0xee, 0xcb, 0xd7, 0x25, 0xed, + 0xd5, 0xeb, 0x92, 0xf6, 0xd7, 0xeb, 0x92, 0xf6, 0xe2, 0x4d, 0x69, 0xec, 0xd5, 0x9b, 0xd2, 0xd8, + 0x1f, 0x6f, 0x4a, 0x63, 0x4f, 0xae, 0x79, 0x7e, 0xd4, 0x6c, 0x37, 0x2a, 0x0e, 0xdd, 0xe3, 0x5f, + 0x23, 0x6e, 0x88, 0x0f, 0x13, 0xf1, 0x1f, 0x92, 0xea, 0xd3, 0xae, 0x0f, 0x23, 0x87, 0x2d, 0xcc, + 0x1a, 0xa7, 0xf8, 0x47, 0x89, 0x5b, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0xa3, 0xa3, 0x3d, 0x21, + 0x82, 0x12, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1378,6 +1473,7 @@ type MsgClient interface { EnableCCTX(ctx context.Context, in *MsgEnableCCTX, opts ...grpc.CallOption) (*MsgEnableCCTXResponse, error) DisableCCTX(ctx context.Context, in *MsgDisableCCTX, opts ...grpc.CallOption) (*MsgDisableCCTXResponse, error) UpdateGasPriceIncreaseFlags(ctx context.Context, in *MsgUpdateGasPriceIncreaseFlags, opts ...grpc.CallOption) (*MsgUpdateGasPriceIncreaseFlagsResponse, error) + UpdateOperationalFlags(ctx context.Context, in *MsgUpdateOperationalFlags, opts ...grpc.CallOption) (*MsgUpdateOperationalFlagsResponse, error) } type msgClient struct { @@ -1496,6 +1592,15 @@ func (c *msgClient) UpdateGasPriceIncreaseFlags(ctx context.Context, in *MsgUpda return out, nil } +func (c *msgClient) UpdateOperationalFlags(ctx context.Context, in *MsgUpdateOperationalFlags, opts ...grpc.CallOption) (*MsgUpdateOperationalFlagsResponse, error) { + out := new(MsgUpdateOperationalFlagsResponse) + err := c.cc.Invoke(ctx, "/zetachain.zetacore.observer.Msg/UpdateOperationalFlags", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. type MsgServer interface { AddObserver(context.Context, *MsgAddObserver) (*MsgAddObserverResponse, error) @@ -1510,6 +1615,7 @@ type MsgServer interface { EnableCCTX(context.Context, *MsgEnableCCTX) (*MsgEnableCCTXResponse, error) DisableCCTX(context.Context, *MsgDisableCCTX) (*MsgDisableCCTXResponse, error) UpdateGasPriceIncreaseFlags(context.Context, *MsgUpdateGasPriceIncreaseFlags) (*MsgUpdateGasPriceIncreaseFlagsResponse, error) + UpdateOperationalFlags(context.Context, *MsgUpdateOperationalFlags) (*MsgUpdateOperationalFlagsResponse, error) } // UnimplementedMsgServer can be embedded to have forward compatible implementations. @@ -1552,6 +1658,9 @@ func (*UnimplementedMsgServer) DisableCCTX(ctx context.Context, req *MsgDisableC func (*UnimplementedMsgServer) UpdateGasPriceIncreaseFlags(ctx context.Context, req *MsgUpdateGasPriceIncreaseFlags) (*MsgUpdateGasPriceIncreaseFlagsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method UpdateGasPriceIncreaseFlags not implemented") } +func (*UnimplementedMsgServer) UpdateOperationalFlags(ctx context.Context, req *MsgUpdateOperationalFlags) (*MsgUpdateOperationalFlagsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateOperationalFlags not implemented") +} func RegisterMsgServer(s grpc1.Server, srv MsgServer) { s.RegisterService(&_Msg_serviceDesc, srv) @@ -1773,6 +1882,24 @@ func _Msg_UpdateGasPriceIncreaseFlags_Handler(srv interface{}, ctx context.Conte return interceptor(ctx, in, info, handler) } +func _Msg_UpdateOperationalFlags_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateOperationalFlags) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateOperationalFlags(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zetachain.zetacore.observer.Msg/UpdateOperationalFlags", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateOperationalFlags(ctx, req.(*MsgUpdateOperationalFlags)) + } + return interceptor(ctx, in, info, handler) +} + var _Msg_serviceDesc = grpc.ServiceDesc{ ServiceName: "zetachain.zetacore.observer.Msg", HandlerType: (*MsgServer)(nil), @@ -1825,6 +1952,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ MethodName: "UpdateGasPriceIncreaseFlags", Handler: _Msg_UpdateGasPriceIncreaseFlags_Handler, }, + { + MethodName: "UpdateOperationalFlags", + Handler: _Msg_UpdateOperationalFlags_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "zetachain/zetacore/observer/tx.proto", @@ -2705,6 +2836,69 @@ func (m *MsgUpdateGasPriceIncreaseFlagsResponse) MarshalToSizedBuffer(dAtA []byt return len(dAtA) - i, nil } +func (m *MsgUpdateOperationalFlags) 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 *MsgUpdateOperationalFlags) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateOperationalFlags) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.OperationalFlags.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintTx(dAtA, i, uint64(len(m.Creator))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateOperationalFlagsResponse) 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 *MsgUpdateOperationalFlagsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateOperationalFlagsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + func encodeVarintTx(dAtA []byte, offset int, v uint64) int { offset -= sovTx(v) base := offset @@ -3077,6 +3271,30 @@ func (m *MsgUpdateGasPriceIncreaseFlagsResponse) Size() (n int) { return n } +func (m *MsgUpdateOperationalFlags) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Creator) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.OperationalFlags.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgUpdateOperationalFlagsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + func sovTx(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -5405,6 +5623,171 @@ func (m *MsgUpdateGasPriceIncreaseFlagsResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *MsgUpdateOperationalFlags) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateOperationalFlags: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateOperationalFlags: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Creator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OperationalFlags", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.OperationalFlags.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgUpdateOperationalFlagsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateOperationalFlagsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateOperationalFlagsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipTx(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/zetaclient/chains/interfaces/interfaces.go b/zetaclient/chains/interfaces/interfaces.go index 4f00b7a2bb..a8fe9c71fc 100644 --- a/zetaclient/chains/interfaces/interfaces.go +++ b/zetaclient/chains/interfaces/interfaces.go @@ -136,6 +136,7 @@ type ZetacoreClient interface { ) ([]crosschaintypes.OutboundTracker, error) GetCrosschainFlags(ctx context.Context) (observertypes.CrosschainFlags, error) GetRateLimiterFlags(ctx context.Context) (crosschaintypes.RateLimiterFlags, error) + GetOperationalFlags(ctx context.Context) (observertypes.OperationalFlags, error) GetObserverList(ctx context.Context) ([]string, error) GetBTCTSSAddress(ctx context.Context, chainID int64) (string, error) GetZetaHotKeyBalance(ctx context.Context) (sdkmath.Int, error) diff --git a/zetaclient/maintenance/shutdown_listener.go b/zetaclient/maintenance/shutdown_listener.go new file mode 100644 index 0000000000..0ac3b18d75 --- /dev/null +++ b/zetaclient/maintenance/shutdown_listener.go @@ -0,0 +1,125 @@ +package maintenance + +import ( + "context" + "time" + + "cosmossdk.io/errors" + "github.com/rs/zerolog" + + "github.com/zeta-chain/node/pkg/bg" + "github.com/zeta-chain/node/pkg/retry" + observertypes "github.com/zeta-chain/node/x/observer/types" + "github.com/zeta-chain/node/zetaclient/chains/interfaces" +) + +const restartListenerTicker = 10 * time.Second + +// ShutdownListener is a struct that listens for scheduled shutdown notices via the observer +// operational flags +type ShutdownListener struct { + client interfaces.ZetacoreClient + logger zerolog.Logger + + lastRestartHeightMissed int64 +} + +// NewShutdownListener creates a new ShutdownListener. +func NewShutdownListener(client interfaces.ZetacoreClient, logger zerolog.Logger) *ShutdownListener { + log := logger.With().Str("module", "shutdown_listener").Logger() + return &ShutdownListener{ + client: client, + logger: log, + } +} + +func (o *ShutdownListener) Listen(ctx context.Context, action func()) { + var ( + withLogger = bg.WithLogger(o.logger) + onComplete = bg.OnComplete(action) + ) + + bg.Work(ctx, o.waitForUpdate, bg.WithName("shutdown_listener.wait_for_update"), withLogger, onComplete) +} + +func (o *ShutdownListener) waitForUpdate(ctx context.Context) error { + operationalFlags, err := retry.DoTypedWithBackoffAndRetry( + func() (observertypes.OperationalFlags, error) { return o.client.GetOperationalFlags(ctx) }, + retry.DefaultConstantBackoff(), + ) + if err != nil { + return errors.Wrap(err, "unable to get initial operational flags") + } + if o.handleNewFlags(ctx, operationalFlags) { + return nil + } + + ticker := time.NewTicker(restartListenerTicker) + defer ticker.Stop() + + for { + select { + case <-ticker.C: + operationalFlags, err = o.client.GetOperationalFlags(ctx) + if err != nil { + return errors.Wrap(err, "unable to get operational flags") + } + if o.handleNewFlags(ctx, operationalFlags) { + return nil + } + case <-ctx.Done(): + o.logger.Info().Msg("waitForUpdate (shutdown listener) stopped") + return nil + } + } +} + +// handleNewFlags processes the flags and returns true if a shutdown should be signaled +func (o *ShutdownListener) handleNewFlags(ctx context.Context, f observertypes.OperationalFlags) bool { + if f.RestartHeight < 1 { + return false + } + + currentHeight, err := o.client.GetBlockHeight(ctx) + if err != nil { + o.logger.Error().Err(err).Msg("unable to get block height") + return false + } + + if f.RestartHeight < currentHeight { + // only log restart height misseed once + if o.lastRestartHeightMissed != f.RestartHeight { + o.logger.Error(). + Int64("restart_height", f.RestartHeight). + Int64("current_height", currentHeight). + Msg("restart height missed") + } + o.lastRestartHeightMissed = f.RestartHeight + return false + } + + o.logger.Warn(). + Int64("restart_height", f.RestartHeight). + Int64("current_height", currentHeight). + Msg("restart scheduled") + + newBlockChan, err := o.client.NewBlockSubscriber(ctx) + if err != nil { + o.logger.Error().Err(err).Msg("unable to subscribe to new blocks") + return false + } + for { + select { + case newBlock := <-newBlockChan: + if newBlock.Block.Height >= f.RestartHeight { + o.logger.Warn(). + Int64("restart_height", f.RestartHeight). + Int64("current_height", newBlock.Block.Height). + Msg("restart height reached") + return true + } + case <-ctx.Done(): + return false + } + } +} diff --git a/zetaclient/maintenance/shutdown_listener_test.go b/zetaclient/maintenance/shutdown_listener_test.go new file mode 100644 index 0000000000..2b2c9128d1 --- /dev/null +++ b/zetaclient/maintenance/shutdown_listener_test.go @@ -0,0 +1,107 @@ +package maintenance + +import ( + "context" + "testing" + "time" + + cometbfttypes "github.com/cometbft/cometbft/types" + "github.com/rs/zerolog" + "github.com/stretchr/testify/require" + observertypes "github.com/zeta-chain/node/x/observer/types" + "github.com/zeta-chain/node/zetaclient/testutils/mocks" +) + +func assertChannelNotClosed[T any](t *testing.T, ch <-chan T) { + select { + case <-ch: + t.FailNow() + default: + } +} + +func newBlockEventHeightOnly(height int64) cometbfttypes.EventDataNewBlock { + return cometbfttypes.EventDataNewBlock{ + Block: &cometbfttypes.Block{ + Header: cometbfttypes.Header{ + Height: height, + }, + }, + } +} + +func TestShutdownListener(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + logger := zerolog.New(zerolog.NewTestWriter(t)) + + t.Run("scheduled shutdown", func(t *testing.T) { + client := mocks.NewZetacoreClient(t) + + listener := NewShutdownListener(client, logger) + + client.Mock.On("GetOperationalFlags", ctx).Return(observertypes.OperationalFlags{ + RestartHeight: 10, + }, nil) + client.Mock.On("GetBlockHeight", ctx).Return(int64(8), nil) + blockChan := make(chan cometbfttypes.EventDataNewBlock) + client.Mock.On("NewBlockSubscriber", ctx).Return(blockChan, nil) + + complete := make(chan interface{}) + listener.Listen(ctx, func() { + close(complete) + }) + + assertChannelNotClosed(t, complete) + + blockChan <- newBlockEventHeightOnly(9) + assertChannelNotClosed(t, complete) + + blockChan <- newBlockEventHeightOnly(10) + <-complete + }) + + t.Run("no shutdown", func(t *testing.T) { + client := mocks.NewZetacoreClient(t) + + listener := NewShutdownListener(client, logger) + + client.Mock.On("GetOperationalFlags", ctx).Return(observertypes.OperationalFlags{}, nil) + // GetBlockHeight is not mocked because we want the test to panic if it's called + // NewBlockSubscriber is not mocked because we want the test to panic if it's called + complete := make(chan interface{}) + listener.Listen(ctx, func() { + close(complete) + }) + + require.Eventually(t, func() bool { + return len(client.Calls) == 1 + }, time.Second, time.Millisecond) + + assertChannelNotClosed(t, complete) + }) + + t.Run("shutdown height missed", func(t *testing.T) { + client := mocks.NewZetacoreClient(t) + + listener := NewShutdownListener(client, logger) + + client.Mock.On("GetOperationalFlags", ctx).Return(observertypes.OperationalFlags{ + RestartHeight: 10, + }, nil) + client.Mock.On("GetBlockHeight", ctx).Return(int64(11), nil) + + complete := make(chan interface{}) + listener.Listen(ctx, func() { + close(complete) + }) + + require.Eventually(t, func() bool { + return len(client.Calls) == 2 + }, time.Second, time.Millisecond) + assertChannelNotClosed(t, complete) + cancel() + }) + // avoid Log in goroutine after TestShutdownListener has completed + time.Sleep(time.Millisecond * 100) +} diff --git a/zetaclient/testutils/mocks/zetacore_client.go b/zetaclient/testutils/mocks/zetacore_client.go index fefd653874..cd834aba73 100644 --- a/zetaclient/testutils/mocks/zetacore_client.go +++ b/zetaclient/testutils/mocks/zetacore_client.go @@ -918,6 +918,30 @@ func (_m *ZetacoreClient) NewBlockSubscriber(ctx context.Context) (chan cometbft return r0, r1 } +// GetOperationalFlags provides a mock function with given fields: ctx +func (_m *ZetacoreClient) GetOperationalFlags(ctx context.Context) (observertypes.OperationalFlags, error) { + ret := _m.Called(ctx) + + var r0 observertypes.OperationalFlags + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (observertypes.OperationalFlags, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) observertypes.OperationalFlags); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(observertypes.OperationalFlags) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // NewZetacoreClient creates a new instance of ZetacoreClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. // The first argument is typically a *testing.T value. func NewZetacoreClient(t interface { diff --git a/zetaclient/zetacore/client_operationalflags.go b/zetaclient/zetacore/client_operationalflags.go new file mode 100644 index 0000000000..5359cf25d7 --- /dev/null +++ b/zetaclient/zetacore/client_operationalflags.go @@ -0,0 +1,12 @@ +package zetacore + +import ( + "context" + + observertypes "github.com/zeta-chain/node/x/observer/types" +) + +func (c *Client) GetOperationalFlags(ctx context.Context) (observertypes.OperationalFlags, error) { + res, err := c.Observer.OperationalFlags(ctx, &observertypes.QueryOperationalFlagsRequest{}) + return res.OperationalFlags, err +}